Java 继承

继承

1. 继承：比如说有两个类，这两个类有共同的属性，（把这些共同的属性抽取出来，达到代码的复用效果），把共同的属性当成一个类，这两个类再继承这一个类

2. 继承的语法，extends表示子类继承父类

访问限定修饰符 class 子类 extends 父类{

} 

// Animal.java
public class Animal {
    String name;
    int age;

    public void eat() {
        System.out.println(name+ "正在吃饭");
    }

    public void sleep() {
        System.out.println(name+ "正在睡觉");
    }

}
// Dog.java 
public class Dog extends Animal{
    public Dog() {
        super();
    }

    void bark() {
        System.out.println(name+ "汪汪汪~~~");
    }
}

3. 子类会把父类的成员方法和成员变量继承到子类中
4. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

访问父类成员

子类和父类不存在同名变量

1. 直接使用

public class Animal {
    String name;
    int age;
}

public class Dog extends Animal{
    double weight;
    String color;


    public Dog(String name,int age,double weight,String color) {
        this.name = name;//从父类中继承下来的name
        this.age = age;//从父类中继承下来的age
        this.weight = weight;
        this.color = color;
    }
}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog("阿狗",3,20.5,"黑色");
        //dog类中并没有定义任何成员变量,name和age属性是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        System.out.println(dog.weight);
        System.out.println(dog.color);
    }
}

子类和父类存在同名变量

1. 优先使用子类的变量和方法

public class Animal {
    String name;
    int age;
    int a = 3;
}

public class Dog extends Animal{
    double weight;
    String color;
    int a = 0;
    
    public void method() {
        System.out.println(a);//此时a是访问父类继承的a还是子类自己的a呢?
    }
}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.method();//输出结果为0,说明method()中的a是子类自己的
    }
}

注意, 在子类方法中 或者 通过子类对象访问成员时 ：
如果访问的成员变量子类中有，优先访问自己的成员变量。
如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
如果访问的成员变量与父类中成员变量同名，则优先访问自己的。
总结就是一句话:就近原则,先找自己的,再找父类的.

在父类成员变量与子类成员变量相同时,想要访问父类成员变量时该如何访问呢?

super

1. super 关键字，该关键字主要作用：在子类方法中访问父类的成员变量和方法 。
   2. super(); 在子类的构造方法中调用父类的构造进行初始化继承下来的变量

public class Animal {
    String name = "父类";
    int age = 1;
    public void methodA() {
        System.out.println("父类中的A方法");
    }

    public void methodB() {
        System.out.println("父类中的B方法");
    }
}

public class Dog extends Animal{
    String name = "子类";
    int age = 2;

    public void methodA(int a) {
        System.out.println("子类中的A(a)方法");
    }

    public void methodB() {
        System.out.println("子类中的B方法");
    }

    public void methodC() {
        System.out.println(name);//访问子类的name,
        System.out.println(age);//访问子类的age
        System.out.println(super.name);//访问父类的name
        System.out.println(super.age);//访问父类的age
    }
}

public class TestExtend {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.methodC();
    }
}

super关键字：

1. 只能在非静态方法中使用
2. 在子类方法中，访问父类的成员变量和方法 。

父类的构造初始化

1. 在子类完成构造之前，要调用父类的构造，进行从父类继承过来的成员变量的初始化

2. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的 super()调用，即调用父类构造方法，且super()只能在子类构造方法中出现一次，并且只能在子类构造方法的第一句
3. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

public Dog() {
    //super();super();没写时,Java在第一行默认有隐含的super();
    System.out.println("子类构造方法");
}

4. 如果有多个父类的构造，在子类中想要怎么初始化自己继承的变量就调用哪个父类的构造

this和super的对比

1. 相同点：

a. 都是关键字

b. 都只能在非静态方法中使用，用来访问非静态成员方法和变量

c. 在构造方法中调用，都只能是构造方法的第一句，并且不能同时存在

2. 不同点：

a. this是当前对象的引用,当前对象即调用实例方法的对象,super相当于是子类对象中从父类继承部分成员的引用

b. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

c. 构造方法中：this用来调用本类的构造方法，super用来调用父类的构造方法，两种方法不能同时在构造方法中出现，因为他们都要在第一句

d. 构造方法中一定会存在super()的调用，即使你不写，编译器也会默认加上，但是this用户不写，就没有

初始化

1. 请判断执行顺序？
   优先执行父类的静态，在执行子类的静态，在执行父类的实例和构造，最后执行子类的实例和构造
   因为父类要先于子类之前初始化

protected

1. protected是在继承的场景下使用的，前提是继承的父类是public修饰的
2. protected和private修饰的类是会报错的
   
   

final

1. 被final修饰的变量就变为常量了，只能被初始化一次
2. 被final修饰的类不能被继承

final public class A{

}

final int a = 10;
// a = 20; 不能再被修改 

3. 被final修饰的方法不能被重写，是密封方法

继承和组合

1. 继承最好不超过三层

2. 组合：代码复用的另一种方式，将一个类的实例作为另一个类的字段（变量）

3. 组合：把另一个类作为当前类的成员变量，达到了类的复用的效果

class Engine {
    void start() {
        System.out.println("Engine started");
    }
}

class Car {
    把Engine类当做Car类的成员变量
    private Engine engine; // Car 拥有 Engine（组合）

    public Car() {
        this.engine = new Engine(); // Engine 由 Car 控制生命周期
    }

    void start() {
        engine.start(); // 调用 Engine 的方法
        System.out.println("Car started");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
    }
}