Java继承简介

继承的本质：是代码的复用，重复使用已经定义好的方法和域（即全局变量）

要掌握继承首先要了解Java方法的重载和重写

方法的重载和重写

方法的重载

当前方法名相同，但是参数类型不同，发生重载

类比数学函数公式

重载发生在同一个类当中

方法的重写

发生在类的继承中， 子类重写父类的方法

方法名和参数列表必须相同

构造器就是典型的方法的重载

重写的特点：

子类优先调用自己重写后的方法，如果没有，向上寻找

继承中类的加载顺序

static代码块：在main方法执行之前执行，且执行一次。

先执行父类static，再执行子类static：创建子类对象之前，先创建父类对象

扫描加载----------->执行

加载的时候，一定先把父类加载到虚拟机。加载的时候注意父类和接口。先加载父类再加载子类，防止子类调用父类方法或域时无法找到

创建子类对象之前，一定先创建了父类对象

对象初始化顺序：

方法不调用不执行

方法块可以直接执行

方法块的优先级高于构造方法

方法块和属性谁在上面谁先执行

静态方法的属性或代码块优先级高于其他，同级别之间顺序按先后执行

静态优先级最高，且只初始化一次，即只执行一次

class Demo_1{
// 下面代码执行顺序： c --> 代码块1 --> a --> 代码块2 --> b --> 构造方法public Demo_1(){System.out.println("俺是构造方法:"+a);}public int a=10;{System.out.println("俺是代码块1:"+a);    }public int b =20;{System.out.println("俺是代码块2");    }public static int  c =90;public static Demo_1 s = new Demo_1();static{System.out.println("俺是静态代码块3");    }
}
// 产生多少个对象，非静态的代码块就执行多少次
// 但静态的只执行一次
public class Demo_1_Test{public static void main(String[] args){// main 方法中只有4个对象//Demo_1类中的static对象 s 只执行一次Demo_1 x1 = new Demo_1();Demo_1 x2 = new Demo_1();Demo_1 x3 = new Demo_1();}
}

以上代码运行结果：

俺是代码块1:10
俺是代码块2
俺是构造方法:10
俺是静态代码块3
俺是代码块1:10
俺是代码块2
俺是构造方法:10
俺是代码块1:10
俺是代码块2
俺是构造方法:10
俺是代码块1:10
俺是代码块2
俺是构造方法:10

静态的执行时间是类的首次使用时，是第一个对象产生的时候触发的，且仅由类的第一个对象触发——即静态的初始化是在第一个对象产生的时候触发的，且仅由类的第一个对象触发

子类对象产生时，一定会产生一个父类对象

父类对象一定优先于子类对象产生，父类的初始化一定优先于子类

父类静态 --> 子类静态 --> 父类非静态 --> 父类构造方法 --> 子类非静态 --> 子类构造方法。静态和非静态属性和代码块都有，按先后顺序初始化。

class Demo_1{public Demo_1(){System.out.println("俺是Demo_1构造方法");}{System.out.println("俺是代码块Demo_1");    }static{System.out.println("俺是静态代码块Demo_1");    }
}
// 子类对象产生时，一定会产生一个父类对象
// 父类对象一定优先于子类对象产生
class Demo_2 extends Demo_1{public Demo_2(){System.out.println("俺是Demo_2构造方法");}{System.out.println("俺是代码块Demo_2");    }static{System.out.println("俺是静态代码块Demo_2");    }
}public class Demo_1_Test{public static void main(String[] args){Demo_1 x1 = new Demo_1();Demo_2 x2 = new Demo_2();}
}

 上述代码执行结果：

俺是静态代码块Demo_1
俺是代码块Demo_1
俺是Demo_1构造方法
俺是静态代码块Demo_2
俺是代码块Demo_1
俺是Demo_1构造方法
俺是代码块Demo_2
俺是Demo_2构造方法

从内存的角度来理解，什么是方法的重写

子类重写了父类的方法，在子类调用该方法时，父类的该方法失效。

// AAA.java
package 继承;public class AAA {public void testA() {System.out.println("该方法当中有很多逻辑运算----》AAA");}public  AAA(String name) {System.out.println(name+"，俺是AAA的构造函数！");}}
// BBB.java
package 继承;public class BBB extends AAA {public void name() {//调用父类的方法super.testA();   }public void run() {testA();}public void run(String name) {}public void testA() {System.out.println("该方法当中有很多逻辑运算----》BBB");}public BBB(String name) {super(name);System.out.println(name+"，俺是BBB的构造函数！");}
}
// Test.java
package 继承;public class Test{public static void main(String[] args) {BBB bbb= new BBB("你好");bbb.testA();}
}

对上面的继承关系，main方法作为程序入口，开始执行程序。

new关键字创建了一个类BBB，而类BBB继承了类AAA，程序先将类AAA复制一份代码进入堆区，此内存区域内包括testA()方法，bbb指向的内存空间中，还包括BBB类的方法。内存示意图如下

在类AAA中添加方法testB()但在类BBB中未添加重写的方法，bbb也可以直接调用testB()方法。

public class AAA {// 其他方法public void testB() {System.out.println("该方法当中有很多BBB逻辑运算----》AAA");}}
package 继承;public class Test{public static void main(String[] args) {BBB bbb= new BBB("你好");bbb.testA();bbb.testB();}
}

bbb调用testB()会先在类BBB中寻找方法，没有此方法向上级类中继续寻找，如果直接父类中没有定义该方法，则继续向上寻找。等价于在类BBB中重写方法testB()，方法体中只有super.testB()。

但是final修饰的方法不可被重写。

super关键字

了解即可

本质两个用途：调用父类的普通方法；调用父类的构造器

调用父类的普通方法时，可以不使用super

调用父类构造器时只能在子类构造器中使用，并且必须写在子类构造器的第一行

Java的继承层次

Java只有单继承：即一个子类只能有一个父类，一个父类可以有多个子类

总结

1、重载发生在类内，重写发生在有继承关系的不同类中

2、子类对象创建之前先创建父类对象

3、程序初始化顺序：先父类再子类，先静态再非静态，构造方法在最后

注意：初始化顺序和执行顺序不一样，初始化指程序进入内存的顺序。