设计模式：组合模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）-CSDN博客
| 阿里云国内75折 回扣 微信号：monov8 |
| 阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6 |
简介
组合模式它是一种用于处理树形结构、表示“部分-整体”层次结构的设计模式。它允许你将对象组合成树形结构以表示部分和整体的关系。这种模式的主要目的是简化客户端代码并使客户端以一致的方式处理单个对象和组合对象。
在组合模式中抽象根节点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该类通常包含一些共有的属性和方法例如添加、删除子节点等。
public abstract class Component
{
public virtual void Operation()
{
// 具体实现留给子类去完成
}
}然后创建具体组件类Leaf该类继承自抽象组件类并实现具体的业务逻辑。
public class Leaf : Component
{
public override void Operation()
{
// 具体实现留给子类去完成
}
}接下来创建复合组件类Composite该类同样继承自抽象组件类并添加对子节点的管理操作例如添加、删除子节点等。
public class Composite : Component, ICollection<Component>
{
private List<Component> children = new List<Component>();
public void Add(Component component)
{
children.Add(component);
}
public void Remove(Component component)
{
children.Remove(component);
}
public override void Operation()
{
foreach (var child in children)
{
child.Operation(); // 递归调用子节点的Operation方法
}
}
}最后在客户端代码中可以通过创建复合组件类的实例来管理整个树形结构而无需关心具体的叶子节点或复合组件类的内部实现细节。
public class Client {
public void test() {
Composite root = new Composite(); // 创建根节点
Leaf leaf1 = new Leaf(); // 创建叶子节点1
Leaf leaf2 = new Leaf(); // 创建叶子节点2
Composite composite1 = new Composite(); // 创建复合节点1
Composite composite2 = new Composite(); // 创建复合节点2
// 将节点添加到相应的复合节点中或者直接添加到根节点下
root.Add(leaf1);
root.Add(leaf2);
composite1.Add(leaf1);
composite2.Add(leaf2);
root.Add(composite1);
root.Add(composite2);
// 调用根节点的Operation方法将递归遍历整个树形结构并执行相应的操作
root.Operation();
}
}二、java组合模式
组合模式通常通过以下方式实现
//首先定义一个抽象组件类Component该类通常包含一些共有的属性和方法例如添加、删除子节点等。
public abstract class Component {
public void add(Component component) {
// 具体实现留给子类去完成
}
public void remove(Component component) {
// 具体实现留给子类去完成
}
public void operation() {
// 具体实现留给子类去完成
}
}
//然后创建具体组件类Leaf该类继承自抽象组件类并实现具体的业务逻辑。
public class Leaf extends Component {
@Override
public void operation() {
// 具体实现留给子类去完成
}
}
//接下来创建复合组件类Composite该类同样继承自抽象组件类并添加对子节点的管理操作例如添加、删除子节点等。
public class Composite extends Component {
private List<Component> children = new ArrayList<>();
@Override
public void add(Component component) {
children.add(component);
}
@Override
public void remove(Component component) {
children.remove(component);
}
@Override
public void operation() {
for (Component child : children) {
child.operation(); // 递归调用子节点的operation方法
}
}
}
//最后在客户端代码中可以通过创建复合组件类的实例来管理整个树形结构而无需关心具体的叶子节点或复合组件类的内部实现细节。
public class Client {
public static void main(String[] args) {
Composite root = new Composite(); // 创建根节点
Leaf leaf1 = new Leaf(); // 创建叶子节点1
Leaf leaf2 = new Leaf(); // 创建叶子节点2
Composite composite1 = new Composite(); // 创建复合节点1
Composite composite2 = new Composite(); // 创建复合节点2
// 将节点添加到相应的复合节点中或者直接添加到根节点下
root.add(leaf1);
root.add(leaf2);
composite1.add(leaf1);
composite2.add(leaf2);
root.add(composite1);
root.add(composite2);
// 调用根节点的operation方法将递归遍历整个树形结构并执行相应的操作
root.operation();
}
}三、javascript组合模式
在JavaScript中组合模式的实现方式如下
//定义一个抽象组件类
class Component {
constructor(name) {
this.name = name;
this.children = [];
}
addChild(component) {
this.children.push(component);
}
removeChild(component) {
this.children = this.children.filter(child => child !== component);
}
printTree() {
console.log(this.name);
this.children.forEach(child => child.printTree());
}
}
//创建具体组件类
class Leaf extends Component {
constructor(name) {
super(name);
}
printLeaf() {
console.log(`${this.name} (Leaf)`);
}
}
//创建复合组件类
class Composite extends Component {
constructor(name) {
super(name);
}
addChild(component) {
if (component instanceof Leaf) {
super.addChild(component);
} else if (component instanceof Composite) {
component.children.forEach(child => this.addChild(child));
} else {
throw new Error('Invalid component type');
}
}
}四、C++组合模式
以下是在C++中实现组合模式
#include <iostream>
class Component {
public:
virtual void operation() = 0;
};
class Leaf : public Component {
public:
Leaf(int value) : m_value(value) {}
void operation() override { std::cout << "Leaf operation: " << m_value << std::endl; }
private:
int m_value;
};
class Composite : public Component {
public:
Composite() {}
void addChild(Component* child) { m_children.push_back(child); }
void removeChild(Component* child) { m_children = m_children.erase(std::remove(m_children.begin(), m_children.end(), child)); }
void operation() override {
for (auto child : m_children) {
child->operation();
}
}
private:
std::vector<Component*> m_children;
};
int main() {
Composite* root = new Composite();
Leaf* leaf1 = new Leaf(1);
Leaf* leaf2 = new Leaf(2);
Composite* composite1 = new Composite();
Composite* composite2 = new Composite();
root->addChild(leaf1);
root->addChild(leaf2);
composite1->addChild(leaf1);
composite2->addChild(leaf2);
root->addChild(composite1);
root->addChild(composite2);
root->operation();
}五、python组合模式
以下是在python中实现组合模式
class Component:
def operation(self):
pass
class Leaf(Component):
def __init__(self, value):
self.value = value
def operation(self):
print(f"Leaf operation: {self.value}")
class Composite(Component):
def __init__(self):
self.children = []
def add_child(self, child):
self.children.append(child)
def remove_child(self, child):
self.children = [c for c in self.children if c != child]
def operation(self):
for child in self.children:
child.operation()
def main():
root = Composite()
leaf1 = Leaf(1)
leaf2 = Leaf(2)
composite1 = Composite()
composite2 = Composite()
root.add_child(leaf1)
root.add_child(leaf2)
composite1.add_child(leaf1)
composite2.add_child(leaf2)
root.add_child(composite1)
root.add_child(composite2)
root.operation()
if __name__ == "__main__":
main()在这个示例代码中定义了一个Component类作为抽象组件类它有一个operation()方法用于实现组件的操作。Leaf类和Composite类继承自Component类分别表示叶节点和复合节点。Leaf类有一个value属性表示节点的值而Composite类有一个children属性用于存储子节点。Composite类还实现了add_child()和remove_child()方法用于添加和删除子节点。最后在main()函数中创建了一个对象树并调用operation()方法来执行操作。
六、go组合模式
以下是一个示例展示了如何在go中实现组合模式
package main
import "fmt"
type Component interface {
Operation()
}
type Leaf struct {
value int
}
func (l *Leaf) Operation() {
fmt.Printf("Leaf operation: %d\n", l.value)
}
type Composite struct {
children []*Component
}
func (c *Composite) Operation() {
for _, child := range c.children {
child.Operation()
}
}
func main() {
root := &Composite{}
leaf1 := &Leaf{value: 1}
leaf2 := &Leaf{value: 2}
composite1 := &Composite{}
composite2 := &Composite{}
root.children = []*Component{leaf1, leaf2, composite1, composite2}
composite1.children = []*Component{leaf1}
composite2.children = []*Component{leaf2}
root.Operation()
}在这个示例代码中定义了一个Component接口它有一个Operation()方法。Leaf和Composite结构体实现了Component接口。Leaf结构体有一个value属性表示节点的值而Composite结构体有一个children属性用于存储子节点。Composite结构体还实现了Operation()方法用于递归地调用子节点的Operation()方法。在main()函数中创建了一个对象树并调用Operation()方法来执行操作。
七、PHP组合模式
以下是一个示例展示了如何在PHP中实现组合模式
<?php
class Component {
protected $name;
protected $children;
public function __construct($name) {
$this->name = $name;
$this->children = [];
}
public function addChild(Component $child) {
$this->children[] = $child;
}
public function removeChild(Component $child) {
$this->children = array_filter($this->children, function ($component) use ($child) {
return $component !== $child;
});
}
public function getName() {
return $this->name;
}
}
class Leaf extends Component {
public function __construct($name) {
parent::__construct($name);
}
}
class Composite extends Component {
public function __construct($name) {
parent::__construct($name);
}
public function getChildren() {
return $this->children;
}
}
// 创建树形结构
$root = new Composite("Root");
$leaf1 = new Leaf("Leaf 1");
$leaf2 = new Leaf("Leaf 2");
$composite1 = new Composite("Composite 1");
$composite2 = new Composite("Composite 2");
$root->addChild($leaf1);
$root->addChild($leaf2);
$composite1->addChild($leaf1);
$composite2->addChild($leaf2);
$root->addChild($composite1);
$root->addChild($composite2);
// 遍历树形结构并输出节点名称
function traverse(Component $node) {
echo $node->getName() . " ";
if ($node instanceof Composite) {
foreach ($node->getChildren() as $child) {
traverse($child);
}
}
}
traverse($root); 在这个示例中Component类是抽象的根类表示树中的节点。Leaf类表示叶节点没有子节点Composite类表示复合节点可以包含子节点。通过addChild()和removeChild()方法可以向复合节点添加或移除子节点。通过getChildren()方法可以获取复合节点的子节点列表。最后使用traverse()函数来遍历树形结构并输出节点名称。
《完结》