• 设计模式：组合模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

    上一篇《模板模式》                                                                    下一篇《代理模式》

    简介：

    组合模式，它是一种用于处理树形结构、表示“部分-整体”层次结构的设计模式。它允许你将对象组合成树形结构，以表示部分和整体的关系。这种模式的主要目的是简化客户端代码，并使客户端以一致的方式处理单个对象和组合对象。

    在组合模式中，抽象根节点（Component）定义了系统各层次对象的公有方法和属性，可以预先定义一些默认行为和属性。树枝节点（Composite）定义了树枝节点的行为，存储子节点，组合树枝节点和叶子节点形成一个树形结构。叶子节点（Leaf）是系统层次遍历的最小单位。

    组合模式的使用场景包括但不限于以下几种情况：

    1、表示部分-整体层次结构：组合模式适用于需要处理部分-整体关系的场景，例如文件系统中的文件夹和文件之间的关系。通过组合模式，可以将文件夹和文件组合在一起，形成一个树形结构，方便用户进行操作和管理。
    2、处理树形结构：组合模式适用于处理树形结构的情况，例如表达式树、决策树等。在这些场景中，可以将对象组合成树形结构，以表示部分和整体的关系，方便对整个树形结构进行操作和管理。
    3、简化客户端代码：组合模式可以简化客户端代码，使得客户端只需要面对一致的对象而不用考虑整体部分或叶子节点的问题。通过组合模式，客户端可以将对组合对象的操作委托给其子对象，而无需知道具体执行的是单个对象还是整个组合。
    4、提高系统的灵活性和可扩展性：组合模式可以使得系统的设计更加灵活和可扩展。通过组合模式，可以轻松地添加新的对象类型，而不需要修改现有的代码。同时，组合模式还可以使得系统更容易适应变化和扩展，提高系统的可维护性和可重用性。

    总之，组合模式适用于需要处理部分-整体关系的场景，以及需要简化客户端代码、提高系统灵活性和可扩展性的情况。在使用组合模式时，需要注意抽象化、封装和继承等问题，以保证代码的正确性和可维护性。

    组合模式的创建步骤如下：
    1、创建抽象组件类（Component），该类通常包含一些共有的属性和方法，例如添加、删除子节点等。
    2、创建具体组件类（Leaf），该类继承自抽象组件类，并实现具体的业务逻辑。
    3、创建复合组件类（Composite），该类同样继承自抽象组件类，并添加对子节点的管理操作，例如添加、删除子节点等。
    4、在复合组件类中实现一些公共操作，例如遍历整个树形结构等。
    5、客户端代码通过调用复合组件类的操作来管理整个树形结构，而无需关心具体的叶子节点或复合组件类的内部实现细节。

    需要注意的是，在实际应用中，需要根据具体需求选择是否使用组合模式，并注意处理好对象组合的层次关系，以及保证代码的正确性和可维护性。

    组合模式的优点，主要包括：
    1、清楚地定义分层次的复杂对象，表示对象的全部或部分层次。这使得增加新构件也更容易，因为可以在已有的层次结构中添加新的节点。
    2、客户端调用简单。客户端可以一致地使用组合结构或其中单个对象，而不必关心处理的是单个对象还是整个组合结构，这简化了客户端代码。
    3、更容易在组合体内加入对象构件。在组合模式中，增加新的容器构件和叶子构件都很方便，无需对现有类库进行任何修改，符合"开闭原则"。
    4、为树型结构的面向对象实现提供了一种灵活的解决方案。通过叶子对象和容器对象的递归组合，可以形成复杂的树型结构，但对树型结构的控制却非常简单。
    总的来说，组合模式能够简化客户端代码，并使得增加新构件和形成复杂树形结构更加容易。同时，它还提供了一种灵活的解决方案，使得面向对象实现更加高效。

    组合模式的缺点，主要包括：
    1、设计较复杂。由于组合模式需要定义抽象组件类、具体组件类和复合组件类，以及它们之间的层次关系和操作，因此设计起来相对复杂。
    2、不容易限制容器中的构件。在组合模式中，容器中的构件可以自由地添加、删除和组合，这可能导致一些问题，例如无限递归、内存泄漏等。
    3、不容易用继承的方法来增加构件的新功能。由于组合模式采用递归组合的方式，而不是通过继承来增加构件的新功能，因此需要手动添加新的构件，这可能会增加代码的复杂度和维护成本。

    示例：

    一、C#组合模式

    以下是一个示例，展示了如何在C#中实现组合模式：

    首先，定义一个抽象组件类（Component），该类通常包含一些共有的属性和方法，例如添加、删除子节点等。

    1. public abstract class Component  
    2. {  
    3.     public virtual void Operation()  
    4.     {  
    5.         // 具体实现留给子类去完成  
    6.     }  
    7. }

    然后，创建具体组件类（Leaf），该类继承自抽象组件类，并实现具体的业务逻辑。

    1. public class Leaf : Component  
    2. {  
    3.     public override void Operation()  
    4.     {  
    5.         // 具体实现留给子类去完成  
    6.     }  
    7. }

    接下来，创建复合组件类（Composite），该类同样继承自抽象组件类，并添加对子节点的管理操作，例如添加、删除子节点等。

    1. public class Composite : Component, ICollection<Component>  
    2. {  
    3.     private List children = new List();  
    4.   
    5.     public void Add(Component component)  
    6.     {  
    7.         children.Add(component);  
    8.     }  
    9.   
    10.     public void Remove(Component component)  
    11.     {  
    12.         children.Remove(component);  
    13.     }  
    14.   
    15.     public override void Operation()  
    16.     {  
    17.         foreach (var child in children)  
    18.         {  
    19.             child.Operation(); // 递归调用子节点的Operation方法  
    20.         }  
    21.     }  
    22. }

    最后，在客户端代码中，可以通过创建复合组件类的实例来管理整个树形结构，而无需关心具体的叶子节点或复合组件类的内部实现细节。

    1. public class Client {  
    2.     public void test() { 
    3.         Composite root = new Composite(); // 创建根节点  
    4.         Leaf leaf1 = new Leaf(); // 创建叶子节点1  
    5.         Leaf leaf2 = new Leaf(); // 创建叶子节点2  
    6.         Composite composite1 = new Composite(); // 创建复合节点1  
    7.         Composite composite2 = new Composite(); // 创建复合节点2  
    8.         // 将节点添加到相应的复合节点中，或者直接添加到根节点下  
    9.         root.Add(leaf1);   
    10.         root.Add(leaf2);   
    11.         composite1.Add(leaf1);   
    12.         composite2.Add(leaf2);   
    13.         root.Add(composite1);   
    14.         root.Add(composite2);   
    15.         // 调用根节点的Operation方法，将递归遍历整个树形结构并执行相应的操作  
    16.         root.Operation();
    17.     }
    18. }

    二、java组合模式

    组合模式通常通过以下方式实现：

    1. //首先，定义一个抽象组件类（Component），该类通常包含一些共有的属性和方法，例如添加、删除子节点等。
    2. public abstract class Component {  
    3.     public void add(Component component) {  
    4.         // 具体实现留给子类去完成  
    5.     }  
    6.   
    7.     public void remove(Component component) {  
    8.         // 具体实现留给子类去完成  
    9.     }  
    10.   
    11.     public void operation() {  
    12.         // 具体实现留给子类去完成  
    13.     }  
    14. }
    15. //然后，创建具体组件类（Leaf），该类继承自抽象组件类，并实现具体的业务逻辑。
    16. public class Leaf extends Component {  
    17.     @Override  
    18.     public void operation() {  
    19.         // 具体实现留给子类去完成  
    20.     }  
    21. }
    22. //接下来，创建复合组件类（Composite），该类同样继承自抽象组件类，并添加对子节点的管理操作，例如添加、删除子节点等。
    23. public class Composite extends Component {  
    24.     private List children = new ArrayList<>();  
    25.   
    26.     @Override  
    27.     public void add(Component component) {  
    28.         children.add(component);  
    29.     }  
    30.   
    31.     @Override  
    32.     public void remove(Component component) {  
    33.         children.remove(component);  
    34.     }  
    35.   
    36.     @Override  
    37.     public void operation() {  
    38.         for (Component child : children) {  
    39.             child.operation(); // 递归调用子节点的operation方法  
    40.         }  
    41.     }  
    42. }
    43. //最后，在客户端代码中，可以通过创建复合组件类的实例来管理整个树形结构，而无需关心具体的叶子节点或复合组件类的内部实现细节。
    44. public class Client {  
    45.     public static void main(String[] args) {
    46.         Composite root = new Composite(); // 创建根节点  
    47.         Leaf leaf1 = new Leaf(); // 创建叶子节点1  
    48.         Leaf leaf2 = new Leaf(); // 创建叶子节点2  
    49.         Composite composite1 = new Composite(); // 创建复合节点1  
    50.         Composite composite2 = new Composite(); // 创建复合节点2  
    51.         // 将节点添加到相应的复合节点中，或者直接添加到根节点下  
    52.         root.add(leaf1);   
    53.         root.add(leaf2);   
    54.         composite1.add(leaf1);   
    55.         composite2.add(leaf2);   
    56.         root.add(composite1);   
    57.         root.add(composite2);   
    58.         // 调用根节点的operation方法，将递归遍历整个树形结构并执行相应的操作  
    59.         root.operation();
    60.     }
    61. }

    三、javascript组合模式

    在JavaScript中，组合模式的实现方式如下：

    1. //定义一个抽象组件类
    2. class Component {  
    3.   constructor(name) {  
    4.     this.name = name;  
    5.     this.children = [];  
    6.   }  
    7.   
    8.   addChild(component) {  
    9.     this.children.push(component);  
    10.   }  
    11.   
    12.   removeChild(component) {  
    13.     this.children = this.children.filter(child => child !== component);  
    14.   }  
    15.   
    16.   printTree() {  
    17.     console.log(this.name);  
    18.     this.children.forEach(child => child.printTree());  
    19.   }  
    20. }
    21. //创建具体组件类
    22. class Leaf extends Component {  
    23.   constructor(name) {  
    24.     super(name);  
    25.   }  
    26.   
    27.   printLeaf() {  
    28.     console.log(`${this.name} (Leaf)`);  
    29.   }  
    30. }
    31. //创建复合组件类
    32. class Composite extends Component {  
    33.   constructor(name) {  
    34.     super(name);  
    35.   }  
    36.   
    37.   addChild(component) {  
    38.     if (component instanceof Leaf) {  
    39.       super.addChild(component);  
    40.     } else if (component instanceof Composite) {  
    41.       component.children.forEach(child => this.addChild(child));  
    42.     } else {  
    43.       throw new Error('Invalid component type');  
    44.     }  
    45.   }  
    46. }

    四、C++组合模式

    以下是在C++中实现组合模式：

    1. #include   
    2.   
    3. class Component {  
    4. public:  
    5.     virtual void operation() = 0;  
    6. };  
    7.   
    8. class Leaf : public Component {  
    9. public:  
    10.     Leaf(int value) : m_value(value) {}  
    11.     void operation() override { std::cout << "Leaf operation: " << m_value << std::endl; }  
    12. private:  
    13.     int m_value;  
    14. };  
    15.   
    16. class Composite : public Component {  
    17. public:  
    18.     Composite() {}  
    19.     void addChild(Component* child) { m_children.push_back(child); }  
    20.     void removeChild(Component* child) { m_children = m_children.erase(std::remove(m_children.begin(), m_children.end(), child)); }  
    21.     void operation() override {  
    22.         for (auto child : m_children) {  
    23.             child->operation();  
    24.         }  
    25.     }  
    26. private:  
    27.     std::vector m_children;  
    28. };  
    29.   
    30. int main() {  
    31.     Composite* root = new Composite();  
    32.     Leaf* leaf1 = new Leaf(1);  
    33.     Leaf* leaf2 = new Leaf(2);  
    34.     Composite* composite1 = new Composite();  
    35.     Composite* composite2 = new Composite();  
    36.     root->addChild(leaf1);  
    37.     root->addChild(leaf2);  
    38.     composite1->addChild(leaf1);  
    39.     composite2->addChild(leaf2);  
    40.     root->addChild(composite1);  
    41.     root->addChild(composite2);  
    42.     root->operation(); 
    43. }

    五、python组合模式

    以下是在python中实现组合模式：

    1. class Component:  
    2.     def operation(self):  
    3.         pass  
    4.   
    5. class Leaf(Component):  
    6.     def __init__(self, value):  
    7.         self.value = value  
    8.       
    9.     def operation(self):  
    10.         print(f"Leaf operation: {self.value}")  
    11.   
    12. class Composite(Component):  
    13.     def __init__(self):  
    14.         self.children = []  
    15.       
    16.     def add_child(self, child):  
    17.         self.children.append(child)  
    18.       
    19.     def remove_child(self, child):  
    20.         self.children = [c for c in self.children if c != child]  
    21.       
    22.     def operation(self):  
    23.         for child in self.children:  
    24.             child.operation()  
    25.   
    26. def main():  
    27.     root = Composite()  
    28.     leaf1 = Leaf(1)  
    29.     leaf2 = Leaf(2)  
    30.     composite1 = Composite()  
    31.     composite2 = Composite()  
    32.     root.add_child(leaf1)  
    33.     root.add_child(leaf2)  
    34.     composite1.add_child(leaf1)  
    35.     composite2.add_child(leaf2)  
    36.     root.add_child(composite1)  
    37.     root.add_child(composite2)  
    38.     root.operation()  
    39.   
    40. if __name__ == "__main__":  
    41.     main()

     在这个示例代码中，定义了一个Component类作为抽象组件类，它有一个operation()方法，用于实现组件的操作。Leaf类和Composite类继承自Component类，分别表示叶节点和复合节点。Leaf类有一个value属性，表示节点的值，而Composite类有一个children属性，用于存储子节点。Composite类还实现了add_child()和remove_child()方法，用于添加和删除子节点。最后，在main()函数中创建了一个对象树，并调用operation()方法来执行操作。    

    六、go组合模式

    以下是一个示例，展示了如何在go中实现组合模式：

    1. package main  
    2.   
    3. import "fmt"  
    4.   
    5. type Component interface {  
    6.  Operation()  
    7. }  
    8.   
    9. type Leaf struct {  
    10.  value int  
    11. }  
    12.   
    13. func (l *Leaf) Operation() {  
    14.  fmt.Printf("Leaf operation: %d\n", l.value)  
    15. }  
    16.   
    17. type Composite struct {  
    18.  children []*Component  
    19. }  
    20.   
    21. func (c *Composite) Operation() {  
    22.  for _, child := range c.children {  
    23.  child.Operation()  
    24.  }  
    25. }  
    26.   
    27. func main() {  
    28.  root := &Composite{}  
    29.  leaf1 := &Leaf{value: 1}  
    30.  leaf2 := &Leaf{value: 2}  
    31.  composite1 := &Composite{}  
    32.  composite2 := &Composite{}  
    33.  root.children = []*Component{leaf1, leaf2, composite1, composite2}  
    34.  composite1.children = []*Component{leaf1}  
    35.  composite2.children = []*Component{leaf2}  
    36.  root.Operation() 
    37. }

    在这个示例代码中，定义了一个Component接口，它有一个Operation()方法。Leaf和Composite结构体实现了Component接口。Leaf结构体有一个value属性，表示节点的值，而Composite结构体有一个children属性，用于存储子节点。Composite结构体还实现了Operation()方法，用于递归地调用子节点的Operation()方法。在main()函数中创建了一个对象树，并调用Operation()方法来执行操作。

    七、PHP组合模式

    以下是一个示例，展示了如何在PHP中实现组合模式：

    1.   
    2.   
    3. class Component {  
    4.     protected $name;  
    5.     protected $children;  
    6.   
    7.     public function __construct($name) {  
    8.         $this->name = $name;  
    9.         $this->children = [];  
    10.     }  
    11.   
    12.     public function addChild(Component $child) {  
    13.         $this->children[] = $child;  
    14.     }  
    15.   
    16.     public function removeChild(Component $child) {  
    17.         $this->children = array_filter($this->children, function ($component) use ($child) {  
    18.             return $component !== $child;  
    19.         });  
    20.     }  
    21.   
    22.     public function getName() {  
    23.         return $this->name;  
    24.     }  
    25. }  
    26.   
    27. class Leaf extends Component {  
    28.     public function __construct($name) {  
    29.         parent::__construct($name);  
    30.     }  
    31. }  
    32.   
    33. class Composite extends Component {  
    34.     public function __construct($name) {  
    35.         parent::__construct($name);  
    36.     }  
    37.   
    38.     public function getChildren() {  
    39.         return $this->children;  
    40.     }  
    41. }  
    42.   
    43. // 创建树形结构  
    44. $root = new Composite("Root");  
    45. $leaf1 = new Leaf("Leaf 1");  
    46. $leaf2 = new Leaf("Leaf 2");  
    47. $composite1 = new Composite("Composite 1");  
    48. $composite2 = new Composite("Composite 2");  
    49. $root->addChild($leaf1);  
    50. $root->addChild($leaf2);  
    51. $composite1->addChild($leaf1);  
    52. $composite2->addChild($leaf2);  
    53. $root->addChild($composite1);  
    54. $root->addChild($composite2);  
    55.   
    56. // 遍历树形结构并输出节点名称  
    57. function traverse(Component $node) {  
    58.     echo $node->getName() . " ";  
    59.     if ($node instanceof Composite) {  
    60.         foreach ($node->getChildren() as $child) {  
    61.             traverse($child);  
    62.         }  
    63.     }  
    64. }  
    65. traverse($root); 

    在这个示例中，Component类是抽象的根类，表示树中的节点。Leaf类表示叶节点，没有子节点；Composite类表示复合节点，可以包含子节点。通过addChild()和removeChild()方法，可以向复合节点添加或移除子节点。通过getChildren()方法，可以获取复合节点的子节点列表。最后，使用traverse()函数来遍历树形结构并输出节点名称。


    《完结》

    上一篇《模板模式》                                                                    下一篇《代理模式》

  • 相关阅读:
    Linux网络：数据链路层 | 以太网帧 | MAC地址 | MTU | ARP协议 | DNS | ICMP协议 | NAT技术
    C语言每日一题（31）相交链表
    Javascript知识【BootStrap技术实现商品页面】
    哈罗数据分析（SQL)笔试
    计算机毕业设计ssm基于web的暗香小店系统的设计与实现80041系统+程序+源码+lw+远程部署
    【Python&RS】基于GDAL修改栅格数据的DN值
    Java GC机制 —— 个人笔记
    【libGDX】ApplicationAdapter生命周期
    【数据结构】树——二叉树
    Keil软件中map文件解析
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/133959941