后端Java开发：第十三天

第十三天：继承 - 面向对象的核心概念

欢迎来到第十三天的学习！今天，我们将深入探讨 Java 中的 继承（Inheritance），这是面向对象编程的四大基本特性之一。继承是指一个类（子类）通过继承另一个类（父类）的属性和方法，从而具备父类的功能，同时可以在子类中扩展新的功能。继承是代码复用的核心机制之一，它有助于提高代码的可维护性和可扩展性。

1. 什么是继承？

继承是面向对象编程中的一种机制，它允许我们创建一个新类（子类），这个新类可以继承一个已有类（父类）的一些特性（字段）和行为（方法）。通过继承，子类可以复用父类的代码，同时还可以根据需要扩展或重写父类的方法。

继承的基本原则：

子类继承父类：子类继承了父类的属性和方法，并且可以在子类中新增属性和方法。
方法重写（Overriding）：子类可以重新定义父类的某些方法。
单继承：Java 中的类是单继承的，也就是说，每个类只能有一个直接父类。

2. 继承的好处

继承有以下几个重要的好处：

代码复用：继承让我们能够复用父类的代码，避免了重复编写相同的代码。
增强可维护性：由于子类共享父类的代码，如果父类发生了变化，只需要修改父类代码，子类无需改变，从而提高了代码的可维护性。
扩展性：通过继承，我们可以在子类中扩展新的功能，或者重写父类的方法，实现特定需求。

3. 如何实现继承？

在 Java 中，继承的实现通过使用 extends 关键字。子类通过 extends 关键字继承父类的属性和方法。

基本语法：

public class 子类 extends 父类 {
    // 子类特有的属性和方法
}

步骤 1：定义父类

首先定义一个父类，包含一些属性和方法。

步骤 2：定义子类

子类通过 extends 关键字继承父类的属性和方法。子类可以使用父类的属性和方法，也可以添加自己独特的属性和方法。

步骤 3：使用父类的构造方法

父类的构造方法可以通过 super() 来调用，子类构造方法可以通过 super 关键字来调用父类的构造器，确保父类的初始化过程。

4. 继承的示例

示例 1：动物类与狗类

在这个例子中，我们有一个 动物类（Animal），它包含基本的属性和行为，然后我们通过继承创建一个 狗类（Dog），它继承了动物类的属性，并扩展了自己特有的方法。

// 父类：Animal
public class Animal {
    private String name;

    // 父类构造方法
    public Animal(String name) {
        this.name = name;
    }

    // 父类方法
    public void speak() {
        System.out.println("Animal makes a sound");
    }

    public String getName() {
        return name;
    }
}

// 子类：Dog
public class Dog extends Animal {
    // 子类构造方法
    public Dog(String name) {
        super(name); // 调用父类的构造方法
    }

    // 子类重写父类方法
    @Override
    public void speak() {
        System.out.println(getName() + " barks");
    }

    public static void main(String[] args) {
        // 创建子类对象
        Dog dog = new Dog("Buddy");
        dog.speak();  // 输出：Buddy barks
    }
}

输出：

Buddy barks

分析：

Dog 继承了 Animal 类，获得了父类的 name 属性和 speak() 方法。
Dog 重写了父类的 speak() 方法，使其表现为 “bark”（叫声）。
子类 Dog 使用 super(name) 调用了父类的构造方法来初始化 name 属性。

示例 2：形状类与圆形类

我们再来看一个简单的图形类的例子。假设我们有一个 Shape 类作为父类，代表一个普通的形状。然后我们可以创建一个 Circle 类继承 Shape，表示圆形。

// 父类：Shape
public class Shape {
    private String color;

    public Shape(String color) {
        this.color = color;
    }

    public void draw() {
        System.out.println("Drawing a shape");
    }

    public String getColor() {
        return color;
    }
}

// 子类：Circle
public class Circle extends Shape {
    private double radius;

    // 子类构造方法
    public Circle(String color, double radius) {
        super(color);  // 调用父类的构造方法
        this.radius = radius;
    }

    // 子类方法
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }

    public static void main(String[] args) {
        // 创建子类对象
        Circle circle = new Circle("Red", 5.0);
        circle.draw();  // 输出：Drawing a circle with radius 5.0
    }
}

输出：

Drawing a circle with radius 5.0

分析：

Circle 类继承了 Shape 类，继承了 color 属性和 draw() 方法。
Circle 类通过 super(color) 调用了父类的构造方法。
Circle 类重写了 draw() 方法，以实现绘制圆形的特定行为。

5. 方法重写（Method Overriding）

在继承中，子类可以重写（Override）父类的方法。这是一个非常重要的概念，它允许子类在继承父类的基础上修改方法的实现，使其行为符合子类的需求。

重写的规则：

子类的方法必须与父类的方法具有相同的名称、返回类型和参数列表。
子类的方法可以有不同的实现。
子类的方法不能减少父类方法的访问权限（即如果父类方法是 public，子类不能将其变为 private）。

重写示例：

class Animal {
    public void sound() {
        System.out.println("Some generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Bark");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        animal.sound();  // 输出：Some generic animal sound
        dog.sound();     // 输出：Bark
    }
}

输出：