Java--类的继承

1.定义类

public class A{
     //1.属性/静态属性
     //2.方法/静态方法
     //3.构造方法
     //4.内部类
     
     //成员级别（menber-level）
     public static void main(String[] args){
     //方法级别（method-level）
     }
}

//顶级（top-level）

1）static静态修饰符：只能修饰成员级
2）访问修饰符
i.public/default/package-private修饰顶级和成员级别
ii.private/protected只能修饰成员级别
3）……
执行代码–方法级别

2.引用和对象的生命周期
1）引用：一种数据类型，含义是指向一个对象。
2）对象的生命周期：
i.new分配空间时期
ii.初始化时期
iii.活跃时期
iiii.垃圾时期
3）类的加载–运行期间
i.从磁盘上把*.class文件（类的字节码文件)载入到内存中的过程
使用的是类加载器(ClassLoader)
ii.类(主要)被加载区域：内存的方法区(主要是方法语句数据、静态属性、元信息)
iii.类加载机制：懒加载(延迟加载)，需要时才加载
iiii.类的使用：*new对象；**访问静态属性/方法；***反射等情况下
iiiii.静态属性初始化顺序：按照书写顺序执行（定义时初始化、静态代码块）

3.编译期间和运行期间
1）编译期间：将源文件(.java)转化为字节码文件(.class)
编译期间运行的不是我们的源代码 ，而是javac程序，我们的源代码只是作为别人程序的一个输入
2）运行期间：运行的是我们的代码，java会启动JVM虚拟机

4.继承
目的：代码的复用性（继承要表达的是一种有关系的类）
语法：class 父类名称{} class 子类名称 extends 父类名称{}
注意：父类的属性，除了private修饰的属性不能直接被子类访问，其他都可以

5.方法的覆写问题
方法重载Overload：方法名称相同+形参列表不同
方法签名：方法名称+形参列表
方法覆写Override：子类重写了父类的方法，方法名称相同，形参列表相同，返回值类型相同（允许返回值类型是父类返回值类型的子类）
总结：一定是发生在子类上的
1）必须实现和父类方法名称+形参列表+返回值类型相同的方法
2）目的：针对同一行为，表现出和父类不同的方式
3）子类访问限定符不能比父类更封闭
4）一般建议用@override注释解释

6.super关键字
1）super用来访问父类的构造方法
2）不是代表父类对象，明确调用父类方法
3）super不是引用

class A{
     public int a=10;
     public void print(){sout("父类的print");}
}
class B extends A{
     public int a=100;
     public void print(){sout("子类的print");}
     public void test(){super.a; super.print();}//明确调用父类的a、父类的方法
}

7.java中类的继承只允许单继承

8.继承实例

父类：

public class List {
    protected int size = 0;

    public void insert(int index, int element) {
        System.out.println("没实现");
    }

    public void pushFront(int element) {
        insert(0, element);
    }
    public void pushBack(int element) {
        insert(size, element);
    }
}

子类：

import java.util.Arrays;
//顺序表
public class ArrayList extends List {
    private int[] array = new int[10];

    @Override
    public void insert(int index, int element) {
        for (int i = size; i > index; i--) {
            array[i] = array[i - 1];
        }

        array[index] = element;
        size++;

        int[] a = Arrays.copyOfRange(array, 0, size); // [0,size)
        String s = Arrays.toString(a);
        System.out.println(s);
    }

    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.pushBack(1);
        list.pushBack(2);
        list.pushBack(3);
        list.pushFront(10);
        list.pushFront(20);
        list.pushFront(30);
        list.insert(3, 100);
    }
}

运行结果：

9.子类和父类之间的关系
1）类加载的关系:子类的加载一定触发父类的加载，父类的加载一定是发生在子类加载之前
2）对象实例化/构造的关系：子类的对象构造过程会触发父类中属性的初始化过程，父类属性初始化一定发生在子类属性初始化之前
属性的初始化：i. 定义时初始化+构造代码按书写顺序。ii构造方法（和super调用父类构造方法位置无关）

class A {
    static {
        System.out.println("这是 A 的静态代码块");
    }
}

class B extends A {
    static {
        System.out.println("这是 B 的静态代码块");
    }
}

public class ClassLoadOrder {
    public static void main(String[] args) { 
        System.out.println("开始");
        new B(); 
        System.out.println("结束");
    }
}

运行结果：

class A {
    static {
        System.out.println("这是 A 的静态代码块");
    }
}

class B extends A {
    static {
        System.out.println("这是 B 的静态代码块");
    }
}

public class ClassLoadOrder extends B { //继承自B
    public static void main(String[] args) { //static mian 调用静态方法触发类的加载 --- 优先加载父类
        System.out.println("开始");
        new B(); //不会触发类的加载  因为类已经被加载到内存里了
        System.out.println("结束");

    }
}

运行结果：

class AA {
    int a = initA();
    private int initA() {
        System.out.println("AA 初始化 a");
        return 0;
    }
    {
        System.out.println("AA 的构造代码块");
    }
    AA(int x) {
        System.out.println("AA 的构造方法");
    }
}

class BB extends AA {
    int b = initB();
    private int initB() {
        System.out.println("BB 初始化 b");
        return 0;
    }
    {
        System.out.println("BB 的构造代码块");
    }
    BB(int x) {
        super(x);
        System.out.println("BB 的有参构造方法");
    }
    BB() {
        this(100);
        System.out.println("BB 的无参构造方法");
    }
}

public class InstanceOrder {
    public static void main(String[] args) {
        new BB();
    }
}

运行结果：