Java Composition的实现方式有哪些

在Java中，组合（Composition）是一种设计原则，它允许我们通过将对象组合在一起来实现代码复用和模块化。组合通常比继承更灵活，因为它允许我们在运行时动态地改变对象的行为。以下是Java中实现组合的一些常见方式：

1. 直接在类中包含其他类的对象

最简单的组合方式是在一个类中直接声明另一个类的对象作为成员变量。

public class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

public class Car {
    private Engine engine;

    public Car() {
        this.engine = new Engine();
    }

    public void startCar() {
        engine.start();
        System.out.println("Car started");
    }
}

2. 使用接口

通过接口，我们可以实现更灵活的组合，因为不同的类可以实现同一个接口。

public interface Drivable {
    void start();
}

public class Engine implements Drivable {
    @Override
    public void start() {
        System.out.println("Engine started");
    }
}

public class Car {
    private Drivable drivable;

    public Car(Drivable drivable) {
        this.drivable = drivable;
    }

    public void startCar() {
        drivable.start();
        System.out.println("Car started");
    }
}

3. 使用集合

如果需要组合多个对象，可以使用集合（如List、Set等）来管理这些对象。

import java.util.ArrayList;
import java.util.List;

public class Car {
    private List<Drivable> drivables;

    public Car() {
        this.drivables = new ArrayList<>();
    }

    public void addDrivable(Drivable drivable) {
        drivables.add(drivable);
    }

    public void startCar() {
        for (Drivable drivable : drivables) {
            drivable.start();
        }
        System.out.println("Car started");
    }
}

4. 使用工厂模式

工厂模式可以帮助我们创建和管理组合对象。

public interface DrivableFactory {
    Drivable createDrivable();
}

public class EngineFactory implements DrivableFactory {
    @Override
    public Drivable createDrivable() {
        return new Engine();
    }
}

public class Car {
    private Drivable drivable;

    public Car(DrivableFactory factory) {
        this.drivable = factory.createDrivable();
    }

    public void startCar() {
        drivable.start();
        System.out.println("Car started");
    }
}

5. 使用依赖注入框架

依赖注入框架（如Spring）可以帮助我们更方便地管理对象的创建和依赖关系。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    private Drivable drivable;

    @Autowired
    public Car(Drivable drivable) {
        this.drivable = drivable;
    }

    public void startCar() {
        drivable.start();
        System.out.println("Car started");
    }
}

总结

组合是一种强大的设计原则，可以通过多种方式在Java中实现。选择哪种方式取决于具体的应用场景和需求。直接在类中包含对象是最简单的方式，而使用接口、集合、工厂模式和依赖注入框架则提供了更大的灵活性和可扩展性。