Java 中的类继承（extends class）

简介

在 Java 编程语言中，类继承（extends class）是一项强大的特性，它允许创建一个新类，该新类继承自一个现有的类。通过继承，新类可以重用现有类的属性和方法，同时还能根据自身需求进行扩展和修改。这不仅提高了代码的可维护性和可复用性，还促进了软件设计中的层次结构和模块化。本文将深入探讨 Java 中类继承的基础概念、使用方法、常见实践以及最佳实践。

基础概念

在 Java 中，被继承的类称为父类（superclass）或基类，继承父类的新类称为子类（subclass）或派生类。子类继承了父类的所有非私有属性和方法，这意味着子类可以直接使用这些成员，就好像它们是自己定义的一样。同时，子类还可以定义自己特有的属性和方法，以满足特定的需求。

继承通过 extends 关键字来实现，其语法如下：

class Subclass extends Superclass {
    // 子类的属性和方法
}

使用方法

定义父类

首先，我们需要定义一个父类。父类包含了一些通用的属性和方法，这些属性和方法将被子类继承。

// 定义一个父类 Animal
class Animal {
    private String name;

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

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

    public String getName() {
        return name;
    }
}

定义子类

接下来，我们定义一个子类，该子类继承自 Animal 类。

// 定义一个子类 Dog，继承自 Animal 类
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

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

访问父类成员

子类可以直接访问父类的非私有成员。在子类中，可以使用 super 关键字来访问父类的构造函数、属性和方法。

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

在上述代码中，dog.eat() 调用了父类 Animal 的 eat 方法，dog.bark() 调用了子类 Dog 自己定义的 bark 方法。

常见实践

方法重写

子类可以重写父类的方法，以提供自己的实现。方法重写需要满足以下条件： 1. 方法名、参数列表和返回类型必须与父类中的方法相同（返回类型可以是父类方法返回类型的子类型，这称为协变返回类型）。 2. 子类方法的访问修饰符不能比父类方法的访问修饰符更严格。

下面是一个方法重写的示例：

class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound.");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Animal();
        animal.makeSound(); // 输出：Animal makes a sound.

        Cat cat = new Cat();
        cat.makeSound(); // 输出：Meow!

        Animal catAsAnimal = new Cat();
        catAsAnimal.makeSound(); // 输出：Meow!，这体现了多态性
    }
}

构造函数调用

子类的构造函数可以通过 super 关键字调用父类的构造函数。如果子类构造函数没有显式调用父类构造函数，Java 会自动调用父类的无参构造函数。

class Parent {
    private int value;

    public Parent(int value) {
        this.value = value;
        System.out.println("Parent constructor with value: " + value);
    }
}

class Child extends Parent {
    public Child(int value) {
        super(value);
        System.out.println("Child constructor");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child(10);
    }
}

在上述代码中，Child 类的构造函数通过 super(value) 调用了 Parent 类的构造函数。

最佳实践

合理设计继承层次

继承层次应该设计得清晰、简洁，符合现实世界的逻辑。父类应该包含通用的属性和方法，子类应该在父类的基础上进行合理的扩展。避免创建过于复杂或深层次的继承层次，以免增加代码的维护难度。

避免多重继承陷阱

Java 不支持多重继承（一个类不能直接继承多个父类），因为这可能导致代码的复杂性和冲突。如果需要实现类似多重继承的功能，可以使用接口（interface）。

使用接口实现多继承特性

接口是一种抽象类型，它只包含方法签名，不包含方法的实现。一个类可以实现多个接口，从而实现类似于多重继承的功能。

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying.");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming.");
    }
}

小结

Java 中的类继承（extends class）是一种强大的特性，它允许子类继承父类的属性和方法，从而提高代码的可复用性和可维护性。通过方法重写和构造函数调用等常见实践，子类可以根据自身需求对父类的行为进行定制。在实际开发中，遵循合理设计继承层次、避免多重继承陷阱以及使用接口实现多继承特性等最佳实践，可以使代码更加健壮、易于维护和扩展。