面向对象编程基础：继承¶

概述¶

在面向对象编程（OOP）中，继承是一个重要的概念。它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并且可以在不修改父类的情况下扩展或修改其行为。

继承的主要目的是实现代码的重用和层次化设计。通过继承，我们可以创建一个通用的父类，然后派生出多个子类，每个子类都可以继承父类的特性，并根据需要添加或修改功能。

继承的基本概念¶

父类和子类¶

父类（Superclass）：也称为基类或超类，是被继承的类。它包含了一些通用的属性和方法。
子类（Subclass）：也称为派生类，是继承父类的类。子类可以继承父类的属性和方法，并且可以添加新的属性和方法，或者重写父类的方法。

继承的类型¶

单继承：一个子类只能继承一个父类。Java 支持单继承。
多继承：一个子类可以继承多个父类。Java 不支持多继承，但可以通过接口实现类似的功能。

继承的关键字¶

extends：用于声明一个类继承另一个类。
super：用于调用父类的构造方法或访问父类的成员。

代码示例¶

示例 1：简单的继承¶

// 父类
class Animal {
    // 父类的属性
    String name;

    // 父类的方法
    void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类继承父类
class Dog extends Animal {
    // 子类的方法
    void bark() {
        System.out.println(name + " is barking.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建子类对象
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat();  // 调用继承自父类的方法
        dog.bark(); // 调用子类的方法
    }
}

解释： - Animal 是父类，包含一个属性 name 和一个方法 eat()。 - Dog 是子类，继承了 Animal 类，并添加了一个新的方法 bark()。 - 在 Main 类中，我们创建了一个 Dog 对象，并调用了继承自父类的方法 eat() 和子类的方法 bark()。

示例 2：方法重写¶

// 父类
class Animal {
    void makeSound() {
        System.out.println("Animal is making a sound.");
    }
}

// 子类继承父类并重写方法
class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat is meowing.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建子类对象
        Cat cat = new Cat();
        cat.makeSound(); // 调用重写后的方法
    }
}

解释： - Animal 类有一个 makeSound() 方法。 - Cat 类继承了 Animal 类，并重写了 makeSound() 方法。 - 在 Main 类中，我们创建了一个 Cat 对象，并调用了重写后的 makeSound() 方法。

示例 3：使用 `super` 关键字¶

// 父类
class Vehicle {
    String type;

    // 父类的构造方法
    Vehicle(String type) {
        this.type = type;
    }

    void display() {
        System.out.println("This is a " + type + ".");
    }
}

// 子类继承父类
class Car extends Vehicle {
    String brand;

    // 子类的构造方法
    Car(String type, String brand) {
        super(type); // 调用父类的构造方法
        this.brand = brand;
    }

    @Override
    void display() {
        super.display(); // 调用父类的方法
        System.out.println("Brand: " + brand);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建子类对象
        Car car = new Car("Car", "Toyota");
        car.display(); // 调用重写后的方法
    }
}

解释： - Vehicle 类有一个属性 type 和一个构造方法，以及一个 display() 方法。 - Car 类继承了 Vehicle 类，并添加了一个新的属性 brand。 - 在 Car 类的构造方法中，使用 super(type) 调用了父类的构造方法。 - 在 Car 类的 display() 方法中，使用 super.display() 调用了父类的 display() 方法，并添加了新的输出。

练习题¶

练习 1：简单的继承¶

创建一个 Person 类，包含属性 name 和方法 introduce()，该方法输出 "My name is [name]."。
创建一个 Student 类，继承 Person 类，并添加属性 studentId 和方法 study()，该方法输出 "[name] is studying."。
在 Main 类中创建 Student 对象，并调用 introduce() 和 study() 方法。

练习 2：方法重写¶

创建一个 Shape 类，包含方法 draw()，输出 "Drawing a shape."。
创建一个 Circle 类，继承 Shape 类，并重写 draw() 方法，输出 "Drawing a circle."。
在 Main 类中创建 Circle 对象，并调用 draw() 方法。

练习 3：使用 `super` 关键字¶

创建一个 Employee 类，包含属性 name 和 salary，以及构造方法和 display() 方法，输出 "Name: [name], Salary: [salary]"。
创建一个 Manager 类，继承 Employee 类，并添加属性 department。
在 Manager 类的构造方法中使用 super 调用父类的构造方法，并重写 display() 方法，输出 "Name: [name], Salary: [salary], Department: [department]"。
在 Main 类中创建 Manager 对象，并调用 display() 方法。

总结¶

继承是面向对象编程中的一个重要概念，允许子类继承父类的属性和方法。
通过继承，可以实现代码的重用和层次化设计。
子类可以重写父类的方法，以提供不同的实现。
使用 super 关键字可以调用父类的构造方法或访问父类的成员。
Java 支持单继承，但可以通过接口实现类似多继承的功能。

通过本主题的学习，你应该能够理解继承的基本概念，并能够在 Java 中实现继承。继续练习和探索，你将能够更好地掌握面向对象编程的其他高级特性。