java继承，final关键字，多态

继承的特点：

Java只支持单继承，不支持多继承。

但支持多层继承

例如： grandfather extends father

son extends father

子类继承父类的非私有成员变量和方法

子类不能继承父类的构造方法

不能为了部分功能而去继承

什么时候使用继承？

继承其实是is a的关系

如果两个类A,B只要符合A是B的一种或者B是A的一种就可以使用继承。

正常情况下，子类中的成员变量和父类中的成员变量名称。

若子类中的成员变量和父类的成员变量名称一样呢，在子类方法中访问一个变量的查找顺序：

在子类方法的局部范围找，有就使用。

在子类的成员范围找，有就使用。

在父类的成员范围找，有就使用。

如果还找不到就报错。

this和super的区别？

分别是什么呢？

this代表本类对应的引用。

super代表父类存储空间的标识（可以理解为父类引用，可以操作父类的成员）

怎么用呢？

A：调用成员变量

this.成员变量 调用本类的成员变量

super.成员变量 调用父类的成员变量

B：调用构造方法

this（…) 调用本类的构造方法

super（…)调用父类的构造方法

C：调用成员方法

this.成员方法 调用本类的成员方法

super.成员方法 调用父类的成员方法

继承中构造方法的关系：

A：子类中所有的构造方法都默认的访问父类中空参的构造方法。

public class demo4 {
    public demo4(){
        System.out.println("这是父类的空参构造方法");
    }
    public demo4(String name){
        System.out.println("这是父类的有参构造方法");
    }

}

public class demo5 extends demo4 {
    public demo5 (){
        System.out.println("这是子类的无参构造方法");
    }
    public demo5( String name){
        System.out.println("这是子类的有参构造方法");
    }

}

public class demoTest {
    public static  void main(String [] args){
        demo5 s = new demo5();
        System.out.println("----------");
      demo5 ss = new demo5("小张");
    }
}

为什么？

因为子类会继承父类中的数据，还可能会使用父类的数据。

所以，子类在初始化之前，一定要先完成父类数据的初始化。

注意：子类每一个构造方法的第一条语句默认都是：super();

如果父类中没有构造方法，怎么办呢？

子类通过super去显示的调用父类其他的带参构造方法

或者 子类通过this调用本类的其他构造方法，本类其他构造方法也必须访问了父类构造。

注意：super（…)或者this（…)必须出现在第一条语句，否则就会有父类数据的多次初始化。

public class demo4 {

    public demo4(String name){
        System.out.println("这是父类的有参构造方法");
    }

}

public class demo5 extends demo4 {
    public demo5 (){
        super("随便给");
        System.out.println("这是子类的无参构造方法");
    }
    public demo5( String name){
        super("随便给");
        System.out.println("这是子类的有参构造方法");
    }

}

public class demoTest {
    public static  void main(String [] args){
        demo5 s = new demo5();
        System.out.println("----------");
      demo5 ss = new demo5("小张");
    }
}

一个类的初始化过程

成员变量进行初始化

默认初始化

显示初始化

构造方法初始化

一个类的静态代码块，构造代码块，构造方法的执行流程

静态代码块>构造代码块>构造方法

静态的内容是随着类的加载而加载

静态代码块的内容会优先执行。

子类初始化之前会进行父类的初始化（分层初始化）

个人理解：super仅仅只要将父类初始化，再初始化子类。但如果分成初始化已将父类初始化，那么super将不再进入。

继承中成员方法的关系：

通常情况子类中的方法和父类的方法声明不一样。

子类中的方法和父类中的方法声明一样，通过子类对象调用方法：先找子类中，看有没有这个方法，有就使用。再看父类中，有无这个方法，有就使用。如果没有就报错。

方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

方法重写的注意事项：

父类中私有方法不能被重写

子类重写父类方法时，访问权限不能更低。

父类静态方法，子类必修通过静态方法进行重写。

final 可以修饰类，方法，变量

特点：

final 可以修饰类，该类不能被继承

final 可以修饰方法，该方法不能被重写

final 可以修饰变量，该变量不能被重新赋值。

final修饰基本数据类型这里不赘述，fianl修饰了就不能改变。

final修饰引用数据类型，不变是地址值。

比如 final Student ss = new Student（）然后 ss= new Student（）；这样子就出错了。final修饰引用数据时不变的是地址值。

final修饰变量的初始化时机

A:被final修饰的变量只能赋值一次

B：在构造方法完毕前。（非静态的常量）

多态概述：

某一个事物，在不同时期表现出来的不同状态

举例：猫可以是猫的类型，猫 m = new 猫（）

同时猫也是动物的一种，可以把猫称为动物

动物 d = new 猫（）

多态的前提和体现：

有继承关系

有方法重写

有父类引用指向子类对象。

父 f = new 子（）

例子：

public class Fu {
public int num=200;
    public void show() {
        System.out.println("这是父类的方法");
    }
}

public class Zi extends  Fu{
    public int num=100;
    public int num1=600;
    public void show(){
        System.out.println("这是子类的方法");
    }
}

public class FuandZi {
public static void main(String [] args){
    Fu f = new Zi();
    System.out.println(f.num);
   // System.out.println(f.num1);
    f.show();
}
}

多态中的成员访问特点：

A：成员变量

编译看左边，运行看左边。

B：构造方法

创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

C：成员方法

编译看左边，运行看右边

D：静态方法

编译看左边，运行看左边。