java 复合优先于继承

原创

mob64ca12d2317d 2024-11-30 08:00:47 ©著作权

©著作权归作者所有：来自51CTO博客作者mob64ca12d2317d的原创作品，请联系作者获取转载授权，否则将追究法律责任

Java 中复合优于继承的实现

在面向对象编程中，一个常见的设计原则是“复合优于继承”。这个原则强调在类之间组合对象的使用，而不是通过继承来扩展类的功能。这有助于提高代码的灵活性和可维护性。本文将指导你如何在 Java 中实现这一原则。

流程概述

在实现“复合优于继承”时，可以按照下面的步骤进行操作。以下是一个简单的流程图，展示了主要步骤：

flowchart TD
    A[定义接口] --> B[实现接口的类]
    B --> C[定义组合类]
    C --> D[在组合类中使用实现类]
    D --> E[测试组合类]

步骤说明

步骤	描述
定义接口	创建一个接口，定义需要实施的功能。
实现接口的类	创建一个或多个类来实现上述接口。
定义组合类	创建一个组合类，持有实现接口类的实例。
在组合类中使用实现类	在组合类中调用实现类的方法，组合其功能。
测试组合类	编写测试代码，确保组合类的功能正常运作。

详细实现

接下来，我们将逐步进行实现，每一步都有具体的代码示例。

1. 定义接口

首先，定义一个接口 Driveable，它将包含一些与车辆相关的方法：

// Driveable.java
public interface Driveable {
    void accelerate(); // 加速方法
    void brake();      // 刹车方法
}

2. 实现接口的类

然后，我们创建几个实现 Driveable 接口的类。我们将定义 Car 和 Bike 两个类。

// Car.java
public class Car implements Driveable {
    @Override
    public void accelerate() {
        System.out.println("汽车加速");
    }

    @Override
    public void brake() {
        System.out.println("汽车刹车");
    }
}

// Bike.java
public class Bike implements Driveable {
    @Override
    public void accelerate() {
        System.out.println("自行车加速");
    }

    @Override
    public void brake() {
        System.out.println("自行车刹车");
    }
}

3. 定义组合类

接下来，创建一个组合类 Vehicle，用来组合不同的 Driveable 实现。

// Vehicle.java
public class Vehicle {
    private Driveable driveable; // 持有一个 Driveable 接口的引用

    public Vehicle(Driveable driveable) {
        this.driveable = driveable; // 通过构造函数注入依赖
    }

    public void accelerate() {
        driveable.accelerate(); // 调用具体实现的加速方法
    }

    public void brake() {
        driveable.brake(); // 调用具体实现的刹车方法
    }
}

4. 在组合类中使用实现类

现在，我们可以在 main 方法中创建 Vehicle 的实例，并传入 Car 或 Bike 的实例。

// Main.java
public class Main {
    public static void main(String[] args) {
        Driveable myCar = new Car(); // 创建 Car 实例
        Vehicle vehicle1 = new Vehicle(myCar); // 组合一个汽车实例

        vehicle1.accelerate(); // 调用加速
        vehicle1.brake(); // 调用刹车

        Driveable myBike = new Bike(); // 创建 Bike 实例
        Vehicle vehicle2 = new Vehicle(myBike); // 组合一个自行车实例

        vehicle2.accelerate(); // 调用加速
        vehicle2.brake(); // 调用刹车
    }
}

5. 测试组合类

以上代码将输出以下内容：

汽车加速
汽车刹车
自行车加速
自行车刹车

这样我们完成了“复合优于继承”的基本实现。通过组合不同的实现类，我们可以增强代码的灵活性。

类图

为了帮助你更好地理解这个结构，以下是它的类图：

classDiagram
    class Driveable {
        +accelerate()
        +brake()
    }
    class Car {
        +accelerate()
        +brake()
    }
    class Bike {
        +accelerate()
        +brake()
    }
    class Vehicle {
        -Driveable driveable
        +accelerate()
        +brake()
    }
    
    Driveable <|-- Car
    Driveable <|-- Bike
    Vehicle o-- Driveable