Java中的继承

继承

1.为什么要有继承

继承是面向对象编程的重要概念之一，它允许一个类（子类）继承另一个类（父类）的属性和方法。继承的主要目的是代码复用和扩展性，通过继承可以避免重复编写相同的代码，同时可以在保留原有功能的基础上，扩展新的功能。

2.什么是继承

继承是面向对象编程中的一种机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以继承父类的公共方法和属性，也可以重写父类的方法和属性。继承的关系可以形成一个类的层次结构，其中子类继承了父类的所有属性和方法，还可以添加自己的新属性和方法。

3.代码示例

public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }

    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    public void bark() {
        System.out.println(getName() + " is barking");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("Tommy", 5);
        animal.eat();
        animal.sleep();

        Dog dog = new Dog("Charlie", 3);
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

解释说明:
这个例子中，Animal类是父类，Dog类是子类。Dog类继承了Animal类的属性和方法，并添加了自己的方法bark。
在Dog类中，使用super关键字调用父类的构造方法，以便初始化父类的属性。在bark方法中，使用getName方法获取父类的name属性。

通过这个例子，你可能对Java继承有一定的认知

现在对这个例子进行详细的解释说明

4.语法说明

1.在Java中要表示类之间的继承关系，需要借助extends关键字，具体如下:

修饰符 class 子类 extends 父类{ //...}

就像代码示例中的

public class Dog extends Animal {
}

2.子类将会把父类的成员变量或者成员方法继承到子类中

就像代码示例中的在Test类中。dog可以调用dog.eat()，dog.sleep()；在dog这个类中并没有写这个方法，而是继承父类 Animal的方法

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal("Tommy", 5);
        animal.eat();
        animal.sleep();

        Dog dog = new Dog("Charlie", 3);
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

3.子类继承父类之后，新添加自己特有的成员

在代码示例中，Dog类添加了自己特有的方法bark()

public class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    public void bark() {
        System.out.println(getName() + " is barking");
    }
}

5.父类成员访问

1.子类中访问父类的成员变量

a.子类和父类不存在同名成员变量，子类可以直接访问父类的成员变量

public class Animal {
    protected String name;
}

public class Dog extends Animal {
    public void printName() {
        System.out.println(name);
    }
}

b.子类和父类成员变量同名，子类可以通过super关键字来访问父类的成员变量

public class Animal {
    protected String name;
}

public class Dog extends Animal {
    protected String name;

    public void printName() {
        System.out.println(name);
        System.out.println(super.name);
    }
}

总结:
在子类方法中或者子类对象访问成员时:
1.如果访问的成员变量子类中有，则优先访问自己的成员变量
2.如果访问的成员变量子类中无，则访问父类继承下来的。如果父类也没有定义，则编译报错
3.如果访问的成员变量与父类成员变量同名，则优先访问自己的，并且子类可以通过super关键字来访问父类的成员变量

成员变量访问遵循就近原则，自己有，优先自己的的，如果没有，则向父类中找。

2.子类中访问父类的成员方法

a.子类和父类成员方法名字不同，子类可以直接调用父类的成员方法

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    public void printEat() {
        System.out.println("Dog is eating");
    }
}

b.子类和父类成员方法名字相同，子类可以通过重写父类的方法来实现不同的功能

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating");
    }
}

总结:
1.通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
2.通过派生类(子类)对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；
3.子类可以通过重写父类的方法来实现不同的功能

前面多次提到，如果子类和父类成员变量或成员方法同名，则可以通过super关键字来访问父类中的成员变量或成员方法，那么什么是super关键字呢?

5.Super关键字

1.为什么要有super关键字

在Java中，子类可以继承父类的属性和方法，当子类需要访问父类中的成员变量或成员方法时，就需要使用super关键字。

2.super关键字的定义

super关键字是Java中的一个关键字，表示父类对象的引用，可以通过super关键字来调用父类的构造方法、成员方法和成员变量。

3.super关键字的作用

1.调用父类的构造方法，以便初始化父类的属性
2.访问父类中的成员变量
3.调用父类中的成员方法
4.在子类中重写父类中的成员方法时，可以使用super关键字来调用父类中的成员方法

4.代码案例

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }
}

public class Dog extends Animal {
    private int age;

    public Dog(String name, int age) {
        //使用super关键字调用父类的构造方法
        super(name);
        this.age = age;
    }

    public void bark() {
        //使用super关键字访问父类中的成员变量
        System.out.println(super.name + " is barking");
    }

    @Override
    public void eat() {
        //使用super关键字调用父类中的eat方法
        super.eat();
        System.out.println(name + " is also eating bones");
    }
}

在上面的代码中，Dog类继承了Animal类，并使用super关键字调用了父类的构造方法，以便初始化父类的属性。在bark方法中，子类使用super关键字访问了父类中的成员变量。在eat方法中，子类重写了父类的方法，并使用super关键字调用了父类中的eat方法。

注意事项:在这里插入代码片

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

6.子类构造方法

子类对象构造时，需要先调用基类构造方法，再执行子类的构造方法

public class Base {
    public Base() {
        System.out.println("Base()");
    }

    public class Derived extends Base {
        public Derived() {
            // super(); 
            System.out.println("Derived()");
        }
    }

    public class Test {
        public static void main(String[] args) {
            Derived d = new Derived();
        }
    }

注意事项:

1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用父类构造方法

   public class Derived extends Base {
       public Derived() {
           // super(); 
           System.out.println("Derived()");
       }
   }

2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。

例如在super关键字的代码案例中

    public Dog(String name, int age) {
        //使用super关键字调用父类的构造方法
        super(name);
        this.age = age;
    }

3. 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
4. super(…)只能在子类构造方法中出现一次，并且不能和this同时出

7.在继承关系下的初始化

class Animal {
    String name;
    static int numAnimals;

    static {
        numAnimals = 0;
        System.out.println("Animal 静态代码块执行");
    }

    {
        System.out.println("Animal 实例代码块执行");
    }

    Animal(String name) {
        this.name = name;
        numAnimals++;
        System.out.println(name + " 构造方法执行");
    }
}

class Dog extends Animal {
    String breed;

    static {
        System.out.println("Dog 静态代码块执行");
    }

    {
        System.out.println("Dog 实例代码块执行");
    }

    Dog(String name, String breed) {
        super(name);
        this.breed = breed;
        System.out.println(name + "是" + breed + " " + "构造方法执行");
    }
}

public class Main {
    public static void main(String[] args) {

        Dog myDog1 = new Dog("Buddy", "哈士奇");
        System.out.println("-----------------------");
        Dog myDog2 = new Dog("Haha", "哈士奇");
    }
}

运行结果:

通过分析执行结果，得出以下结论：

1、静态方法最早执行，父类静态代码块优先于子类静态代码块执行
2.静态方法执行一次，第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
3、父类实例代码块和父类构造方法紧接着执行
4、子类的实例代码块和子类构造方法紧接着再执行

8.继承方式

1.单继承

class Animal {
    void move() {
        System.out.println("This animal is moving.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("This dog is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.move();
        myDog.bark();
    }
}

2.多继承

class Animal {
    void move() {
        System.out.println("This animal is moving.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("This dog is barking.");
    }
}

class Poodle extends Dog {
    void groom() {
        System.out.println("This poodle is being groomed.");
    }
}

public class Main {
    public static void main(String[] args) {
        Poodle myPoodle = new Poodle();
        myPoodle.move();
        myPoodle.bark();
        myPoodle.groom();
    }
}

3.不同的类继承同一个类

class Animal {
    void move() {
        System.out.println("This animal is moving.");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("汪汪汪~~~");
    }
}

class Cat extends Animal {
    void mew() {
        System.out.println("喵喵喵~~~");
    }

}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Cat cat = new Cat();
        dog.move();
        dog.bark();
        cat.move();
        cat.mew();
    }
}

4.多继承(不支持)

//伪代码
public class A {.......}
public class B {.......}
public class C extends A,B {.......}
//Java中不支持多继承

虽然有继承，但是我们并不希望类之间的继承层次太复杂，一般我们不希望出现超过三层的继承关系，如果继承层次太多，就需要考虑对代码进行重构了
如果想要从语法上限制继承，就可以使用final关键字

9.final关键字

1.修饰变量或字段，表示常量(即不能修改)

final int a = 10;
a = 20;//编译出错

2.修饰类:表示此类不能被继承
最典型的是Java中常见的String字符串类

3.修饰方法:表示该方法不能被重写