设计模式解析：组合模式与装饰模式

Disper_

于 2024-08-15 20:31:34 发布

阅读量484

点赞数 10

文章标签：设计模式组合模式

本文链接：https://blog.csdn.net/disper1110/article/details/141231123

版权

组合模式

动机

在软件开发中，处理整体与部分之间的关系时，组合模式是常用的设计选择。此模式将对象组织为树形结构，让客户端能统一对待单个对象和组合对象，简化操作。

结构

组合模式包含以下角色：

Component（抽象构件）：定义叶子和容器对象的共同接口，提供一些默认行为。
Leaf（叶子）：表示树的叶子节点，无法再分解。
Composite（容器）：表示可以包含其他叶子或容器节点的容器对象。
Client（客户端）：通过Component接口对组合对象进行操作。

示例代码

// 抽象构件
interface Component {
    void operation();
}

// 叶子节点
class Leaf implements Component {
    public void operation() {
        // 叶子节点的实现
    }
}

// 容器节点
class Composite implements Component {
    private List<Component> children = new ArrayList<>();

    public void add(Component component) {
        children.add(component);
    }

    public void remove(Component component) {
        children.remove(component);
    }

    public void operation() {
        for (Component component : children) {
            component.operation();
        }
    }
}

// 客户端代码
Component leaf1 = new Leaf();
Component leaf2 = new Leaf();
Composite composite = new Composite();
composite.add(leaf1);
composite.add(leaf2);
composite.operation();

优缺点

优点：

统一处理单个对象与组合对象，简化客户端逻辑。
易于扩展和修改整体结构，符合开闭原则。

缺点：

增加系统复杂性，需理解组合模式的概念。

装饰模式

动机

在软件开发中，经常需要给对象添加额外功能而不修改其原始类。传统的继承方式容易导致类的增多，且静态继承关系无法在运行时动态改变。装饰模式通过组合和委托的方式灵活地为对象添加功能，同时保持原有接口及行为。

结构

装饰模式包含以下角色：

Component（抽象构件）：定义原始类与装饰类的公共接口，可以是抽象类或接口。
ConcreteComponent（具体构件）：实现Component接口的原始类，可以被装饰。
Decorator（抽象装饰类）：实现Component接口，并持有一个Component引用，通过构造函数或setter方法注入。
ConcreteDecorator（具体装饰类）：继承Decorator类，通过调用父类的方法扩展对象功能。

示例代码

// 抽象构件
interface Component {
    void operation();
}

// 具体构件
class ConcreteComponent implements Component {
    public void operation() {
        // 具体实现
    }
}

// 抽象装饰类
class Decorator implements Component {
    private Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    public void operation() {
        component.operation();
    }
}

// 具体装饰类
class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    public void operation() {
        super.operation();
        // 扩展功能
    }
}

// 客户端代码
Component component = new ConcreteDecorator(new ConcreteComponent());
component.operation();

在示例中，通过装饰模式动态添加功能而不需修改原始类。结合组合和委托，可在运行时灵活添加、删除功能，并支持多层嵌套。

优缺点

优点：

灵活地动态添加功能，比继承更优。
支持嵌套装饰，实现更复杂功能扩展。
遵循开闭原则，无需修改原始类即可扩展功能。

缺点：

增加类数量，可能导致类膨胀。
装饰链过长时，影响执行效率。

变形金刚实例中的装饰模式

动机

在变形金刚中，每个角色都有不同形态，比如机器人和车辆。我们希望在运行时动态切换这些形态，而不改变其原有行为。

结构

变形金刚实例包含以下角色：

Transformable（可变形接口）：定义变形方法。
Transformer（变形金刚抽象类）：实现可变形接口，提供默认行为。
CarTransformer（车辆变形金刚）：实现车辆形态的变形方法。
RobotTransformer（机器人变形金刚）：实现机器人形态的变形方法。

示例代码

// 可变形接口
interface Transformable {
    void transform();
}

// 变形金刚抽象类
abstract class Transformer implements Transformable {
    protected String name;

    public Transformer(String name) {
        this.name = name;
    }

    public void transform() {
        System.out.println(name + " 正在变形...");
    }
}

// 车辆变形金刚类
class CarTransformer extends Transformer {
    public CarTransformer(String name) {
        super(name);
    }

    public void transform() {
        super.transform();
        System.out.println(name + " 变身为车辆。");
    }
}

// 机器人变形金刚类
class RobotTransformer extends Transformer {
    public RobotTransformer(String name) {
        super(name);
    }

    public void transform() {
        super.transform();
        System.out.println(name + " 变身为机器人。");
    }
}

// 客户端代码
Transformable bumblebee = new CarTransformer("大黄蜂");
bumblebee.transform();

Transformable optimusPrime = new RobotTransformer("擎天柱");
optimusPrime.transform();