什么是合成复用原则?

合成复用原则（Composite Reuse Principle，CRP） 是面向对象设计中的核心原则之一，其核心思想是：尽量通过“合成/聚合”（组合已有对象）的方式复用代码，而不是通过“继承”。它强调“用关联关系替代继承关系”，以降低类间耦合，提高代码的灵活性和可维护性。

一、核心概念：继承的问题与合成复用的优势

要理解合成复用原则，首先需要明确“为什么要避免过度使用继承”：

1. 继承的缺陷：

   • 继承是一种“强耦合”关系：子类依赖父类的实现细节，若父类修改（如方法签名、逻辑），子类可能需要同步修改，违反“开闭原则”。
   • 继承是“静态”的：编译时就确定了父类，运行时无法动态改变继承关系，灵活性差。
   • 可能导致“继承链臃肿”：多层继承会使类的职责模糊，难以维护（如“正方形继承矩形”的经典反例，因矩形的setWidth和setHeight方法在正方形中逻辑冲突）。

2. 合成复用的优势：

   • 合成（Has-A关系）是“弱耦合”：通过在类中定义其他类的对象作为成员变量，复用其功能，类之间依赖的是“对象的行为”而非“类的实现”。
   • 灵活性高：运行时可动态替换被组合的对象（通过 setter 方法），实现功能的动态扩展。
   • 避免继承链问题：每个类的职责更单一，符合“单一职责原则”。

二、合成复用的两种形式：聚合与组合

在Java中，“合成复用”通过聚合（Aggregation） 或组合（Composition） 实现，二者都是“关联关系”的特例：

• 组合（Composition）：
  表示“整体与部分”的强依赖关系，部分的生命周期由整体控制。例如：Car 包含 Engine，当 Car 对象销毁时，Engine 对象也随之销毁（Engine 不能脱离 Car 独立存在）。

  class Engine {
      public void start() { ... }
  }
  
  class Car {
      // 组合：Car 拥有 Engine，Engine 生命周期依赖于 Car
      private Engine engine = new Engine(); 
      
      public void start() {
          engine.start(); // 复用 Engine 的功能
      }
  }
  

• 聚合（Aggregation）：
  表示“整体与部分”的弱依赖关系，部分可独立于整体存在。例如：Team 包含 Player，Player 可脱离 Team 加入其他团队。

  class Player {
      public void play() { ... }
  }
  
  class Team {
      // 聚合：Team 包含 Player，Player 可独立存在
      private List<Player> players; 
      
      public Team(List<Player> players) {
          this.players = players;
      }
      
      public void startGame() {
          for (Player p : players) {
              p.play(); // 复用 Player 的功能
          }
      }
  }
  

三、Java中的合成复用原则实践：反例与正例

反例：过度使用继承导致的问题

假设需要设计一个“日志记录器”，支持“控制台日志”和“文件日志”，且未来可能新增“数据库日志”。若用继承实现：

// 父类：基础日志功能
class Logger {
    public void log(String message) { ... }
}

// 子类：控制台日志（继承Logger）
class ConsoleLogger extends Logger {
    @Override
    public void log(String message) {
        System.out.println("Console: " + message);
    }
}

// 子类：文件日志（继承Logger）
class FileLogger extends Logger {
    @Override
    public void log(String message) {
        // 写入文件逻辑
    }
}

// 业务类：订单服务（依赖具体日志实现）
class OrderService {
    private ConsoleLogger logger = new ConsoleLogger(); // 强依赖ConsoleLogger
    
    public void createOrder() {
        logger.log("订单创建成功"); // 复用日志功能
    }
}

问题：

• 若 OrderService 需改为“文件日志”，必须修改 OrderService 代码（将 ConsoleLogger 改为 FileLogger），违反开闭原则。
• OrderService 依赖具体实现（ConsoleLogger），而非抽象，耦合度高。

正例：用合成复用替代继承

通过“接口+组合”实现，依赖抽象而非具体：

// 抽象接口：定义日志行为
interface Logger {
    void log(String message);
}

// 具体实现：控制台日志
class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("Console: " + message);
    }
}

// 具体实现：文件日志
class FileLogger implements Logger {
    @Override
    public void log(String message) {
        // 写入文件逻辑
    }
}

// 业务类：通过组合复用日志功能，依赖抽象接口
class OrderService {
    private Logger logger; // 组合Logger接口，而非具体实现
    
    // 通过构造方法注入具体日志实现（依赖注入）
    public OrderService(Logger logger) {
        this.logger = logger;
    }
    
    public void createOrder() {
        logger.log("订单创建成功"); // 复用日志功能
    }
}

// 使用时动态指定日志类型
public class Main {
    public static void main(String[] args) {
        // 控制台日志
        OrderService service1 = new OrderService(new ConsoleLogger());
        service1.createOrder();
        
        // 切换为文件日志（无需修改OrderService）
        OrderService service2 = new OrderService(new FileLogger());
        service2.createOrder();
    }
}

优势：

• OrderService 依赖 Logger 接口，与具体实现解耦，符合“依赖倒置原则”。
• 新增日志类型（如 DatabaseLogger）时，只需实现 Logger 接口，OrderService 无需任何修改，符合开闭原则。
• 运行时可动态切换日志实现（通过构造方法或 setter 注入），灵活性远高于继承。

四、合成复用原则的适用场景

1. 需要复用多个类的功能时：
   若一个类需要复用多个类的功能，继承会导致“多继承”（Java不支持多继承，只能通过接口间接实现，但接口无具体实现），而组合可直接在类中定义多个对象成员，复用多个类的功能。
   例如：Car 需复用 Engine、Wheel、Steering 的功能，通过组合这三个类的对象即可，无需继承。

2. 避免继承带来的耦合时：
   当父类可能频繁修改，或子类不需要父类的全部功能（仅需部分）时，用组合可避免子类受父类变化的影响。
   例如：ArrayList 实现 List 接口，内部通过数组（Object[]）存储数据，复用数组的“动态扩容”功能，而非继承数组（数组是特殊类型，无法被继承）。

3. 需要动态切换功能时：
   组合允许通过 setter 方法动态替换被组合的对象，实现功能的动态调整，而继承在编译时就固定了父类，无法动态改变。
   例如：游戏角色的“武器系统”，通过组合 Weapon 接口的对象（Sword、Bow），可通过 setWeapon() 动态切换武器，无需修改角色类。

五、注意：并非完全排斥继承

合成复用原则并非禁止继承，而是“优先使用合成，必要时使用继承”。当类之间存在明确的“is-a”关系（如 Dog is a Animal），且父类稳定、职责单一，继承是合理的（例如：ArrayList extends AbstractList，AbstractList 提供了 List 接口的部分默认实现，简化子类开发）。

核心原则是：继承用于“类的抽象与泛化”（is-a），组合用于“功能的复用与扩展”（has-a）。

总结

合成复用原则的本质是通过“关联关系”（组合/聚合）实现代码复用，减少对继承的依赖，从而降低类间耦合，提高系统的灵活性和可维护性。在Java开发中，它与SOLID原则（尤其是依赖倒置、开闭原则）相辅相成，是设计模式（如装饰器模式、策略模式、组合模式）的重要思想基础。合理应用合成复用，能让代码更适应业务变化，减少修改带来的风险。