软件设计中的合成复用原则：如何通过组合实现代码复用

软件设计中的合成复用原则：如何通过组合实现代码复用

引用

CSDN

1.

https://blog.csdn.net/rabbitsoft_1987/article/details/144483022

合成复用原则（Composite/Reuse Principle）是软件设计中一个重要的指导原则，它提倡通过组合/聚合的方式来实现代码的复用，而不是通过继承。这一原则能够帮助开发者构建出更加健壮、可维护的软件系统。

什么是合成复用原则

合成复用原则（Composite Reuse Principle，CRP）强调，在软件设计中，应该尽量使用组合/聚合的方式来实现代码的复用，而不是通过继承。继承虽然可以实现代码的重用，但它会增加类之间的耦合度，使得系统变得更加复杂和难以维护。而组合/聚合则提供了一种更为灵活和松耦合的方式来复用代码。

为什么需要合成复用原则

1. 降低耦合度：通过组合/聚合，我们可以减少类之间的直接依赖，降低系统的耦合度。
2. 提高灵活性：组合/聚合允许我们在运行时动态地改变对象的行为，而继承则相对固定。
3. 易于维护：当系统需要变更时，使用组合/聚合的类更容易进行修改和扩展。

如何应用合成复用原则

1. 识别可复用的组件：首先，我们需要识别出系统中可以复用的组件或功能。
2. 使用组合/聚合：然后，通过组合或聚合的方式将这些组件集成到新的类或系统中。
3. 避免过度继承：在可能的情况下，尽量避免使用继承来实现代码的复用。

合成复用原则的反向示例及后果

反向示例（继承滥用）

/**
 * 狗狗基类
 */
public abstract class Dog {
    /**
     * 犬吠
     */
    public abstract void bark();
}
  

/**
 * 飞天狗狗
 */
public class FlyingDog extends Dog {
    @Override
    public void bark() {
        System.out.println("Woof woof! I can fly!");
    }
}
/**
 * 游泳狗狗
 */
public class SwimmingDog extends Dog {
    @Override
    public void bark() {
        System.out.println("Woof woof! I can swim!");
    }
}
  

public class Application {
    public static void main(String[] args) {
        Dog dog = new SwimmingDog();
        dog.bark();
    }
}
  

后果

• 继承层次过深，系统变得复杂。
  
• Dog父子类紧密耦合，难以修改或扩展。
• 如果需要添加其他能力的狗狗或者既会飞行又会游泳对的狗狗，可能需要修改多个类，甚至引入多重继承的问题。

如何避免这个后果的解决方案（正向示例）

正向示例（使用组合）

/**
 * 狗狗基类
 */
public class Dog {
    /**
     * 超能力
     */
    private SuperAbility superAbility;
    /**
     * 添加超能力
     * @param superAbility
     */
    public void addSuperAbility(SuperAbility superAbility) {
        this.superAbility = superAbility;
    }
    /**
     * 犬吠
     */
    public void bark(){
        if(superAbility == null){
            System.out.println("Woof woof! I don't have superAbility.");
        }
        else {
            System.out.println("Woof woof! I can " + superAbility.name() + "!");
        }
    }
}
  

/**
 * 超能力
 */
public interface SuperAbility {
    /**
     * 超能力名称
     * @return
     */
    String name();
}
/**
 * 飞行能力
 */
public class FlyingAbility implements SuperAbility {
    @Override
    public String name() {
        return "fly";
    }
}
/**
 * 游泳能力
 */
public class SwimmingAbility implements SuperAbility {
    @Override
    public String name() {
        return "swim";
    }
}
  

public class Application {
    public static void main(String[] args)
    {
        Dog dog = new Dog();
        dog.addSuperAbility(new SwimmingAbility());
        dog.bark();
    }
}
  

在这个示例中，Dog类通过组合的方式添加超能力SuperAbility，而不是继承。这样，Dog类可以灵活地添加或删除功能（如飞行能力），甚至可以添加多个超能力(将狗狗的超能力改成数组即可)。同时，这也降低了类之间的耦合度，提高了系统的可维护性和可扩展性。

结语

通过实例分析，我们看到了继承滥用的后果以及如何通过组合来避免这些问题。希望这些内容能够帮助大家在未来的软件开发中更加灵活地运用合成复用原则，构建出更加健壮、可维护的软件系统。

本文原文来自CSDN