一、继承的定义

继承是面向对象编程中的一种机制，它允许一个类（子类/派生类）从另一个类（父类/基类）那里继承属性和方法。通过继承，子类可以重用父类的代码，并在此基础上进行扩展或修改。继承是面向对象编程的核心概念之一，它有助于实现代码的重用、扩展和组织。

在继承中，父类通常包含了一些通用的属性和方法，而子类可以继承这些成员，同时可以添加自己特有的成员。这样的关系体现了一种“is-a”（是一个）关系，即子类是父类的一种特殊类型。

二、继承的语法

继承的基本语法使用 extends 关键字，它表示一个类继承另一个类。

示例代码：

// 父类 
public class Superclass { 
    // 父类的成员和方法 
} 

// 子类继承父类 
public class Subclass extends Superclass { 
    // 子类的成员和方法 
}

在上面的例子中，Subclass 是子类，Superclass 是父类。子类通过 extends 关键字继承了父类。子类可以访问父类的公共和受保护成员（字段和方法），但不能直接访问父类的私有成员。若要访问类中的私有成员，可以通过构造的getter、setter方法实现。

三、继承的特点

继承是面向对象编程中的一种重要机制，它具有以下几个主要特点：

子类拥有父类的成员： 子类继承了父类的属性和方法，包括字段（成员变量）和方法。这意味着子类可以直接使用父类的成员，无需重新定义。
子类可以拓展父类： 子类可以在继承的基础上添加新的字段和方法，从而实现功能的拓展。这使得子类具有更丰富的特性，而不仅仅是父类的简单重复。
构造方法的继承： 子类的构造方法可以调用父类的构造方法，以确保父类的初始化工作得以执行。使用 super 关键字来调用父类的构造方法。
层次性： 继承可以形成类的层次结构，即多个类通过继承关系连接在一起。这有助于组织和理解类之间的关系。

四、访问修饰符和继承

在Java中，访问修饰符用于控制类的成员（字段和方法）的访问权限。这些访问修饰符对于继承关系的子类和父类之间的成员访问具有一定的影响，具体权限参考上一篇关于四种访问修饰符的表格解析。

五、super关键字

super 是Java中的一个关键字，用于引用父类的成员（字段或方法），以及调用父类的构造方法。super 的使用主要涉及两个方面：在子类中访问父类的成员和在子类构造方法中调用父类构造方法。

1、访问父类的成员：

在子类中，使用 super 关键字可以引用父类的成员（字段或方法），特别是在子类中有与父类同名的成员时。这是为了明确指示使用的是父类的成员，而不是子类的。示例：

class Animal {
    String name = "Animal";

    void eat() {
        System.out.println("动物在吃东西...");
    }
}

class Dog extends Animal {
    String name = "Dog";

    void display() {
        System.out.println(super.name); // 访问父类的字段
        super.eat(); // 调用父类的方法
        System.out.println("狗在汪汪叫...");
    }
}

public class SuperKeywordExample {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.display();
    }
}

在上述例子中，Dog 类中使用 super.name 来引用父类的字段，以及使用 super.eat() 来调用父类的方法。

2. 在子类构造方法中调用父类构造方法：

在子类的构造方法中，通过使用 super 关键字，可以调用父类的构造方法。这是为了确保在创建子类对象时，先执行父类的初始化操作。示例：

class Animal {
    Animal() {
        System.out.println("Animal constructor");
    }
}

class Dog extends Animal {
    Dog() {
        super(); // 调用父类的构造方法
        System.out.println("Dog constructor");
    }
}

public class SuperKeywordExample {
    public static void main(String[] args) {
        Dog myDog = new Dog();
    }
}

在上述例子中，Dog 类的构造方法通过 super() 调用了父类 Animal 的构造方法，确保在创建 Dog 对象时，首先执行了父类的初始化操作。

值得一提的是，上述代码中我们手动添加了super（）方法，以便于更直观了解到子类继承父类时内部的代码执行顺序，但如果我们删去添加的super（）方法，其构造器中仍然有一个“隐形的”super（）方法在相应位置，也就是说，我们添加的super（）方法，实际上是方便我们阅读，编译器会默认添加。

总的来说，super 关键字在子类中的使用有助于处理继承关系中的成员访问和构造方法调用，确保代码的正确性和合理性。

六、多层继承

1、多层继承

多层继承是指在面向对象编程中，一个类直接继承自另一个类，同时也作为其他类的父类，形成多层继承的层次结构。这种继承关系的设计使得类之间形成一种层次化的结构，其中顶层类（最上层的父类）包含了基本的属性和方法，而底层类（子类）通过继承逐渐特化和扩展这些属性和方法。

以下是一个简单的多层继承的示例：

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

// 子类1
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking");
    }
}

// 子类2，同时也作为其他类的父类
class GermanShepherd extends Dog {
    void guard() {
        System.out.println("German Shepherd is guarding");
    }
}

// 子类3，同时也作为其他类的父类
class PoliceDog extends GermanShepherd {
    void detectCrime() {
        System.out.println("Police Dog is detecting crime");
    }
}

public class MultiLevelInheritanceExample {
    public static void main(String[] args) {
        PoliceDog policeDog = new PoliceDog();
        policeDog.eat();         // 继承自 Animal
        policeDog.bark();        // 继承自 Dog
        policeDog.guard();       // 继承自 GermanShepherd
        policeDog.detectCrime();  // 自身方法
    }
}

在上述示例中，Animal 是最顶层的父类，Dog 是继承自 Animal 的子类，GermanShepherd 继承自 Dog，而 PoliceDog 继承自 GermanShepherd。这样就形成了一个多层继承的层次结构。

需要注意的是，多层继承在某些情况下可能导致代码的复杂性增加，增加理解和维护的难度。因此，在设计类的层次结构时，需要权衡继承的深度和复杂性，避免过度使用多层继承。在某些情况下，使用接口或组合等方式可能更为合适。

2、Obiect类

在Java中，Object 类是所有类的根类（Root Class）。每个类都直接或间接地继承自 Object 类，即使在类的声明中没有显式地使用 extends 关键字指定父类，Java 编译器会默认将其继承自 Object 类。

Object 类在 java.lang 包中，因此不需要导入就可以直接使用。它提供了一些通用的方法，这些方法可以被所有的类直接使用，或者在其他类中被重写。以下是 Object 类的一些重要方法：

toString()方法：
- toString()方法返回对象的字符串表示。默认实现返回一个包含类名和哈希码的字符串。在实际使用中，通常会在自定义类中覆写该方法，以提供更有意义的字符串表示。
equals(Object obj)方法：
- equals() 方法用于比较两个对象是否相等。默认实现比较的是对象的引用是否相同，即比较内存地址。在实际使用中，通常需要在自定义类中覆写该方法，以提供自定义的相等比较规则。
getClass()方法：
- getClass() 方法返回对象的运行时类（Runtime Class）。它返回一个 Class 类型的对象，可以用于获取类的信息。

Object类的这些方法为所有 Java 类提供了通用的行为和接口，使得所有的类都具有一些基本的操作和功能。在自定义类时，可以选择性地覆写这些方法以满足特定需求。

七、继承的注意事项

在使用继承时，有一些注意事项需要考虑，以确保代码的正确性和可维护性：

避免过度继承： 避免使用过多的层次继承，因为过度继承会增加代码的复杂性和难以理解。最好保持继承层次的简洁和清晰。
使用 super 关键字： 在子类中调用父类的方法时，使用 super 关键字可以明确指定调用的是父类的方法。这在有同名方法的情况下尤其重要。
注意构造方法的调用顺序： 子类的构造方法会首先调用父类的构造方法，确保父类的初始化操作得以执行。如果有多层继承，构造方法的调用顺序是从顶层父类一直到最底层子类。
访问修饰符的考虑： 访问修饰符控制着成员（字段和方法）的可见性。子类对于父类的访问受到访问修饰符的限制。了解和合理使用访问修饰符是继承中的重要考虑因素。
避免继承链的过深： 过深的继承链可能导致设计变得复杂，难以维护。在设计中，需要权衡深度和清晰性。

总体来说，继承是一个强大的工具，但需要谨慎使用。了解和遵循继承的注意事项，可以帮助设计出更加清晰、灵活和易于维护的代码结构。

继续深入------继承