使用组合替代继承的核心做法是将父类实例作为当前类的成员变量,并在需要时委托调用其方法。具体实现时,在子类中定义一个私有字段指向父类对象,通过构造函数传入该对象,然后重写或暴露所需的方法,内部直接调用该字段的对应方法。这样做能避免深层继承带来的耦合,同时保持接口的灵活性。

Animal 与 Dog 的继承结构有什么问题
继承结构导致代码僵化且难以复用,因为子类必须继承父类的所有行为,即使某些行为不适用。例如,如果 Animal 有 fly() 方法,而 Dog 不能飞,强行继承会导致逻辑错误或需要抛出异常。组合允许动态选择行为,而不是在编译时固定关系。

public class Animal {
public void eat() {
System.out.println("Eating");
}
}
public class Dog {
private Animal animal;
public Dog(Animal animal) {
this.animal = animal;
}
public void eat() {
animal.eat();
}
public static void main(String[] args) {
Animal dogBehavior = new Animal();
Dog myDog = new Dog(dogBehavior);
myDog.eat(); // Output: Eating
}
}如何为不同行为创建多个组合实例
可以通过注入不同的行为对象来实现多态性,而不需要为每种行为创建新的子类。例如,可以创建一个 Flyable 接口,并让 Dog 持有该接口的实例,从而在运行时切换行为。这种方式比继承更灵活,因为可以在不修改 Dog 类的情况下添加新行为。
使用 Husky 将 pre-commit、pre-push 和 commit-msg 检查集成到仓库中,以便代理和开发人员在更改离开工作站之前运行相同的本地防护措施。
立即学习“Java免费学习笔记(深入)”;

public interface Flyable {
void fly();
}
public class Bird implements Flyable {
public void fly() {
System.out.println("Flying like a bird");
}
}
public class Plane implements Flyable {
public void fly() {
System.out.println("Flying like a plane");
}
}
public class Vehicle {
private Flyable flyable;
public Vehicle(Flyable flyable) {
this.flyable = flyable;
}
public void performFly() {
flyable.fly();
}
public static void main(String[] args) {
Vehicle birdVehicle = new Vehicle(new Bird());
Vehicle planeVehicle = new Vehicle(new Plane());
birdVehicle.performFly(); // Output: Flying like a bird
planeVehicle.performFly(); // Output: Flying like a plane
}
}组合模式下如何处理空值或默认行为
在组合模式中,处理空值或默认行为的关键是在构造函数或 setter 方法中进行非空检查,并提供默认实现。例如,如果 Vehicle 没有指定 Flyable,可以设置一个默认的 NoOpFlyable,它什么都不做。这样可以避免 NullPointerException,并确保程序在缺少依赖时仍能正常运行。

















