Java继承、super关键字、继承的类加载与对象创建过程

一、继承

• extends 代表 继承
• Java 中 Object 是所有类的 父类
• Java 采用 单继承，使用 树状结构进行类的管理(C++、Python 多继承 形成 网状结构)
• 子类 可以 继承父类中被 public 和 protected 修饰的属性和方法

1. 定义一个Animal类 当作父类

package com.qikux.day0727;
/**
 * 动物类
 */
public class Animal {
    /**
     * 动物的年龄
     */
    public int age;
    /**
     * 动物的颜色
     */
    protected String color;
    public void run(){
        System.out.println("动物在运动");
    }
    public void breath(){
        System.out.println("动物在呼吸");
    }
}

2. 定义一个Cat类 继承Animal类[注意：与Animal类不在同一包下]

package com.qikux.day0727Test;
import com.qikux.day0727.Animal;
public class Cat extends Animal {
    public void call(){
        System.out.println(color+"的猫，正在喵喵喵");
    }
}

3. 定义一个CatTest 测试类[注意：与Animal类不在同一包下]

package com.qikux.day0727Test;
import com.qikux.day0727Test.Cat;
public class CatTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.age = 1;

        // 不在同一包下，报错
        /*cat.color = "白色";
        System.out.println(cat.color);*/
        // Cat类继承Animal 但是此时在CatTest类中不能使用。
        cat.call();
        cat.run();
        cat.breath();
    }
}

二、super关键字

• super 代表 超级的意思，调用 父类的信息

• super 可以调用 父类的属性 和 方法 ，和 this 用法一致

• super 可以调用 父类的构造方法， 用法 和 this 调构造方法一致

• 注意1：在构造方法中，默认有super();调用父类构造

• 注意2：调用父类的构造方法,必须出现在第一行 与 this 调构造相同（当冲突时只能有一个，放在第一行）

1. Animal父类

@AllArgsConstructor
public class Animal {
    private int age;
    public String color;
    public void run(){
        System.out.println("动物在运动");
    }
}

2. Cat 子类(和测试类)

public class Cat extends Animal{
    /*public Cat(){
        super();//如果调用父类中的无参构造 可以省略super()
        若父类没有无参构造，需要手动调用有参构造，super(2,"白"); 【不推荐-值写死】
        推荐：自己写有参构造，调用父类的有参构造。
    }*/
    public String name;
    // Cat的有参构造
    public Cat(int age,String color,String name){
        // 调用父类的构造方法,必须出现在第一行 与 this 调构造相同
        super(age,color);// super()是调用父类有参构造的！
        this.name = name;
    }
    /**34
     * 猫的颜色
     */
    private String color;
    /**
     * 猫叫
     */
    public void call(){
        run();
    }
    public void run(){
        System.out.println(name+"是"+super.color+"的猫在走猫步");
    }
    public static void main(String[] args) {
        // 创建一个 猫的对象
        Cat cat = new Cat(2,"白色","小白");
        //cat.color = "白色";
        cat.call();
    }
}

三、继承的类加载与对象创建

为何父类定义了有参构造(无无参构造),子类会报错？

1. 类加载，先加载父类。父类没有无参构造，子类默认的无参构造中有默认的super();语句在调父类无参构造

2. 解决方法1：添加父类的无参构造。解决方法2：子类中的无参构造，super();去调父类的有参构造。解决方法3：子类写有参构造，在有参构造中通过super();调父类有参构造[与方法2类似，但这种更加灵活，不会把值写死]

3. Animal2 父类（演示继承的类加载过程）

public class Animal2 {
    private static int age = 10;
    public String color;
    Animal2(){
        System.out.println("Animal2 无参构造");
    }
    {
        System.out.println("Animal2 普通代码块");
    }
    static {
        System.out.println("静态属性age="+age);
        System.out.println("Animal2 静态代码块");
    }
    public static void run(){
        System.out.println("Animal2 静态方法");
    }
    public void run2(){
        System.out.println("Animal2 普通方法");
    }
}

2. Cat2 子类

public class Cat2 extends Animal2{
    Cat2(){
        System.out.println("Cat2 无参构造");
    }
    {
        System.out.println("cat2 普通代码块");
    }
    static {
        System.out.println("Cat2 静态代码块");
    }
    public static void run(){
        System.out.println("Cat2 静态方法");
    }
    public void run2(){
        System.out.println("Cat2 普通方法");
    }

    public static void main(String[] args) {
        // 创建一个 猫的对象
        Cat2 cat = new Cat2();
    }
}

类加载

• 类加载：

  1. JVM 第一次 读取一个类的时候，会将 .class(字节码文件)读入到内存，这个过程 被称为 类加载
  2. 一个类 最多只会发生 一次类加载， 类加载的产物 是 类对象，用 Class 类型来表示

• 类加载的过程：(递归加载父类)

1. 递归的加载 所有父类的信息
   a) 分配空间
   b) 加载 静态属性，如果有赋值语句，同时完成赋值操作
   c) 加载 静态代码块，并执行代码块中的语句
   d) 如果 有静态属性没有赋值，此时 完成对静态属性的赋值
   e) 将类中的静态方法，全部压入 内存(此时方法是不会执行的)
2. 父类加载完后，再进行 自己的类加载(遵循上述5步)