继承与多态的学习

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

点击查看代码

class testUse {
        String name = "";
        int a = 0;

    public testUse(String name) {
        this.name = name;
    }
}
public class TestUseFa  extends  testUse{


    public TestUseFa() {
        super("qwer");//
        super.name = "123";
        super.a = 0;
        Use();
    }
    public void Use(){
        super.a = 10;
    }
}
public class test {
    public static void main(String args[]){
        TestUseFa test = new TestUseFa();
        System.out.println(test.name);
        System.out.println(test.a);
     }
}

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

接下来是protected关建字了，他能在同一个包中调用，非同一个包内只有继承了才能使用
final能使变量变成常量，不能被更改和继承

多态
多态就是同一件事发生在不同对象就是产生不同结果
多态的发生要以下几个条件
1.必须在继承的条件下
2.子类对父类的方法进行重写
3.通过父类的引用调用重写的方法

点击查看代码

public class TestUseFa  extends  testUse{
    String name;

        public TestUseFa() {
        super("qwer");//


    }
    @Override
    public void Use(){
        System.out.println("测试1");
    }
}


public class TestUseFb extends testUse{
    public TestUseFb() {
        super("123");
    }
@Override
    public void Use(){
        System.out.println("测试2");
    }
}

class testUse {
        String name = "";
        int a = 0;

    protected testUse(String name) {
        this.name = name;
    }


    public void Use(){
        System.out.println("123");
    }
}
public class test {
    public static void main(String args[]){

        testUse test1 = new TestUseFa();//向上转型
        test1.Use();
        testUse test2 = new TestUseFb();
        test2.Use();

     }
}

在这种情况下就是多态，根据对象的不同就会产生不同情况，@Override就是标记重写 重写就是对父类方法的覆盖，有以下注意事项 1.重写是需要构成父子类关系才行 2.重写是方法名，参数，返回值类型必须相同，返回值可以是在形成父子关系是不相同（如int 和 Integer） 3.访问权限必须相同或是比父类的被重写的方法要高 4.private，static修饰的，构造方法等不能重写

向上转型，就是子类类型向父类转变
可以直接赋值，方法传参，返回值等实现向上转型
注意，通过向上转型后不能调用子类独一的方法，只能调用自己的
如果调用的方法会是子类重写过的，就会调用子类的方法，这个叫做动态绑定
动态绑定是编译时才确定（晚绑定），静态绑定时编译前就确定（早绑定）

有向上转型就有向下转型，即父类转型为子类，但这种可能会失败，不安全，用的也较少
避免在构造方法中调用重写方法

点击查看代码

 class B {
    public B() {
        // do nothing
        func();
    }
 
    public void func() {
        System.out.println("B.func()");
    }
 }
 
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
 }
 
public class Test {
    public static void main(String[] args) {
        D d = new D();
    }
 }

结果是D.func() 0