继承与多态的学习

继承就是在原有代码的基础上增添新的功能和方法，可以使新的类有着和继承类的共性，而继承别的类的叫做子类，被继承的叫做父类
点击查看代码

1. class testUse {
2.         String name = "";
3.         int a = 0;
5.     public testUse(String name) {
6.         this.name = name;
7.     }
8. }
9. public class TestUseFa  extends  testUse{
12.     public TestUseFa() {
13.         super("qwer");//
14.         super.name = "123";
15.         super.a = 0;
16.         Use();
17.     }
18.     public void Use(){
19.         super.a = 10;
20.     }
21. }
22. public class test {
23.     public static void main(String args[]){
24.         TestUseFa test = new TestUseFa();
25.         System.out.println(test.name);
26.         System.out.println(test.a);
27.      }
28. }

复制代码

这是个非常简单的代码，但我们可以通过这个代码注意到很多要素继承是需要用关键字extends（注意有s），在这个代码中就是TestUseFa继承了testUse，在继承时需要注意，父类的构造方法必须在子类构造方法中得到使用，用super可以使用父类的方法和变量而在创建一个新的子类时，同时需要将父类的变量初始化，所以在子类构造方法中需要super()来调用父类的构造方法进行初始化，且必须要先初始化父类才能使用子类的成员，同样的，在子类和父类都没有构造方法时编译器会自动帮你创建，但如果你有构造方法了就不会提供了如果子类和父类有相同的成员变量，则编译器会使用子类的；如果子类没有就是用父类的在继承中，引用子类时后可以使用父类的方法，但如果方法名相同，就会发生重载Java中不支持多继承，即一个类继承多个类，可以一个类被多个类继承，但可以通过接口来实现多继承super(...)在子类的构造方法中只能出现一次并且需要放在第一位，所以不能与this一起用1、父类静态代码块优先于子类静态代码块执行，且是最早执行2、父类实例代码块和父类构造方法紧接着执行3、子类的实例代码块和子类构造方法紧接着再执行4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行接下来是protected关建字了，他能在同一个包中调用，非同一个包内只有继承了才能使用
final能使变量变成常量，不能被更改和继承
多态
多态就是同一件事发生在不同对象就是产生不同结果
多态的发生要以下几个条件
1.必须在继承的条件下
2.子类对父类的方法进行重写
3.通过父类的引用调用重写的方法
点击查看代码

1. public class TestUseFa  extends  testUse{
2.     String name;
4.         public TestUseFa() {
5.         super("qwer");//
8.     }
9.     @Override
10.     public void Use(){
11.         System.out.println("测试1");
12.     }
13. }
16. public class TestUseFb extends testUse{
17.     public TestUseFb() {
18.         super("123");
19.     }
20. @Override
21.     public void Use(){
22.         System.out.println("测试2");
23.     }
24. }
26. class testUse {
27.         String name = "";
28.         int a = 0;
30.     protected testUse(String name) {
31.         this.name = name;
32.     }
35.     public void Use(){
36.         System.out.println("123");
37.     }
38. }
39. public class test {
40.     public static void main(String args[]){
42.         testUse test1 = new TestUseFa();//向上转型
43.         test1.Use();
44.         testUse test2 = new TestUseFb();
45.         test2.Use();
47.      }
48. }

复制代码

在这种情况下就是多态，根据对象的不同就会产生不同情况，@Override就是标记重写重写就是对父类方法的覆盖，有以下注意事项1.重写是需要构成父子类关系才行2.重写是方法名，参数，返回值类型必须相同，返回值可以是在形成父子关系是不相同（如int 和 Integer）3.访问权限必须相同或是比父类的被重写的方法要高4.private，static修饰的，构造方法等不能重写向上转型，就是子类类型向父类转变
可以直接赋值，方法传参，返回值等实现向上转型
注意，通过向上转型后不能调用子类独一的方法，只能调用自己的
如果调用的方法会是子类重写过的，就会调用子类的方法，这个叫做动态绑定
动态绑定是编译时才确定（晚绑定），静态绑定时编译前就确定（早绑定）
有向上转型就有向下转型，即父类转型为子类，但这种可能会失败，不安全，用的也较少
避免在构造方法中调用重写方法
点击查看代码

1. class B {
2.     public B() {
3.         // do nothing
4.         func();
5.     }
7.     public void func() {
8.         System.out.println("B.func()");
9.     }
10. }
12. class D extends B {
13.     private int num = 1;
14.     @Override
15.     public void func() {
16.         System.out.println("D.func() " + num);
17.     }
18. }
20. public class Test {
21.     public static void main(String[] args) {
22.         D d = new D();
23.     }
24. }

复制代码

结果是D.func() 0
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！