合成复用原则（Composite Reuse Principle，CRP）是指在软件设计中，尽量使用对象组合/聚合的方式，而不是继承的方式来实现复用。这样可以降低类之间的耦合度，提高系统的灵活性和可维护性。

下面通过5个例子说明合成复用原则：

动物和行为：

在这个例子中，我们有一个Animal类，它具有一个行为（例如，狗叫或猫叫）。不使用合成复用原则的情况下，我们需要为每种动物创建一个子类（如Dog和Cat），并在子类中实现特定的行为。使用合成复用原则，我们可以将行为抽象为一个单独的Behavior类，并为不同的行为创建不同的实现类（如Bark和Meow）。这样，Animal类可以通过组合不同的Behavior对象来实现不同的行为，而不是通过继承。

不使用合成复用原则：

class Animal:
    def eat(self):
        pass

class Dog(Animal):
    def bark(self):
        pass

class Cat(Animal):
    def meow(self):
        pass

使用合成复用原则：

class Animal:
    def __init__(self, behavior):
        self.behavior = behavior

    def eat(self):
        pass

class Behavior:
    def perform(self):
        pass

class Bark(Behavior):
    def perform(self):
        print("Bark")

class Meow(Behavior):
    def perform(self):
        print("Meow")

dog = Animal(Bark())
cat = Animal(Meow())

形状和绘制：

在这个例子中，我们有一个Shape类，它具有一个绘制方法。不使用合成复用原则的情况下，我们需要为每种形状创建一个子类（如Circle和Square），并在子类中实现特定的绘制方法。使用合成复用原则，我们可以将绘制抽象为一个单独的Drawing类，并为不同的形状创建不同的实现类（如CircleDrawing和SquareDrawing）。这样，Shape类可以通过组合不同的Drawing对象来实现不同的绘制方法，而不是通过继承。

不使用合成复用原则：

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print("Draw a circle")

class Square(Shape):
    def draw(self):
        print("Draw a square")

使用合成复用原则：

class Shape:
    def __init__(self, drawing):
        self.drawing = drawing

    def draw(self):
        self.drawing.draw()

class Drawing:
    def draw(self):
        pass

class CircleDrawing(Drawing):
    def draw(self):
        print("Draw a circle")

class SquareDrawing(Drawing):
    def draw(self):
        print("Draw a square")

circle = Shape(CircleDrawing())
square = Shape(SquareDrawing())

交通工具和引擎：

在这个例子中，我们有一个Vehicle类，它具有一个启动引擎的方法。不使用合成复用原则的情况下，我们需要为每种交通工具创建一个子类（如Car和Boat），并在子类中实现特定的启动引擎方法。使用合成复用原则，我们可以将引擎抽象为一个单独的Engine类，并为不同的交通工具创建不同的实现类（如CarEngine和BoatEngine）。这样，Vehicle类可以通过组合不同的Engine对象来实现不同的启动引擎方法，而不是通过继承。

不使用合成复用原则：

class Vehicle:
    def start_engine(self):
        pass

class Car(Vehicle):
    def start_engine(self):
        print("Start car engine")

class Boat(Vehicle):
    def start_engine(self):
        print("Start boat engine")

使用合成复用原则：

class Vehicle:
    def __init__(self, engine):
        self.engine = engine

    def start_engine(self):
        self.engine.start()

class Engine:
    def start(self):
        pass

class CarEngine(Engine):
    def start(self):
        print("Start car engine")

class BoatEngine(Engine):
    def start(self):
        print("Start boat engine")

car = Vehicle(CarEngine())
boat = Vehicle(BoatEngine())

电子设备和操作系统：

在这个例子中，我们有一个Device类，它具有一个启动操作系统的方法。不使用合成复用原则的情况下，我们需要为每种电子设备创建一个子类（如Smartphone和Laptop），并在子类中实现特定的启动操作系统方法。使用合成复用原则，我们可以将操作系统抽象为一个单独的OperatingSystem类，并为不同的电子设备创建不同的实现类（如Android和Windows）。这样，Device类可以通过组合不同的OperatingSystem对象来实现不同的启动操作系统方法，而不是通过继承。

不使用合成复用原则：

class Device:
    def boot(self):
        pass

class Smartphone(Device):
    def boot(self):
        print("Boot Android")

class Laptop(Device):
    def boot(self):
        print("Boot Windows")

使用合成复用原则：

class Device:
    def __init__(self, os):
        self.os = os

    def boot(self):
        self.os.boot()

class OperatingSystem:
    def boot(self):
        pass

class Android(OperatingSystem):
    def boot(self):
        print("Boot Android")

class Windows(OperatingSystem):
    def boot(self):
        print("Boot Windows")

smartphone = Device(Android())
laptop = Device(Windows())

音乐播放器和解码器：

在这个例子中，我们有一个MusicPlayer类，它具有一个播放音乐的方法。不使用合成复用原则的情况下，我们需要为每种音乐格式创建一个子类（如MP3Player和FLACPlayer），并在子类中实现特定的播放方法。使用合成复用原则，我们可以将解码器抽象为一个单独的Decoder类，并为不同的音乐格式创建不同的实现类（如MP3Decoder和FLACDecoder）。这样，MusicPlayer类可以通过组合不同的Decoder对象来实现不同的播放方法，而不是通过继承。

不使用合成复用原则：

class MusicPlayer:
    def play(self):
        pass

class MP3Player(MusicPlayer):
    def play(self):
        print("Play MP3")

class FLACPlayer(MusicPlayer):
    def play(self):
        print("Play FLAC")

使用合成复用原则：

class MusicPlayer:
    def __init__(self, decoder):
        self.decoder = decoder

    def play(self):
        self.decoder.decode()

class Decoder:
    def decode(self):
        pass

class MP3Decoder(Decoder):
    def decode(self):
        print("Play MP3")

class FLACDecoder(Decoder):
    def decode(self):
        print("Play FLAC")

mp3_player = MusicPlayer(MP3Decoder())
flac_player = MusicPlayer(FLACDecoder())

结论

本文介绍了合成复用原则，该原则强调在软件设计中尽量使用对象组合/聚合的方式，而不是继承的方式来实现复用。我们提供了五个例子来说明该原则的应用，并展示了使用合成复用原则的代码示例和PlantUML图形说明。使用合成复用原则可以降低类之间的耦合度，提高系统的灵活性和可维护性。希望这篇文章能够帮助你更好地理解合成复用原则，从而在软件设计中更加灵活和高效地实现复用。