【地铁上的设计模式】--结构型模式：装饰器模式
什么是装饰器模式
装饰器模式是一种结构型设计模式，它允许你通过将对象放入包含行为的特殊封装对象中来为原对象添加新的行为，同时又不改变原有对象的结构。装饰器模式中，包装器对象和被包装对象实现了相同的接口，因此客户端无需知道具体的实现细节，只需通过接口即可使用包装器对象。这种模式能够让你在不修改现有代码的情况下，为已有对象增加新的功能。
如何实现装饰器模式
装饰器模式的实现步骤如下：
- 定义一个接口或抽象类，作为被装饰对象和装饰器的公共接口或抽象父类。
- 定义一个具体的被装饰对象，实现公共接口或继承抽象父类。
- 定义一个装饰器抽象类，它包含一个公共接口或抽象父类的引用，同时也继承了公共接口或抽象父类。
- 定义一个具体的装饰器类，实现装饰器抽象类，通过构造函数接收被装饰对象，并在其基础上添加新的行为或修改原有的行为。
- 可以根据需要再定义其他装饰器类，它们也必须继承装饰器抽象类。
- 最后，使用装饰器类装饰具体的被装饰对象，生成一个新的具有增强功能的对象。
通过这种方式，装饰器模式可以在不改变原有类结构的前提下，动态地扩展一个对象的功能。
Java实现
以下是 Java 实现装饰器模式的示例代码：
// 定义抽象组件
public interface Component {
public void operation();
}
// 定义具体组件
public class ConcreteComponent implements Component {
public void operation() {
System.out.println("具体组件的操作");
}
}
// 定义抽象装饰类
public abstract class Decorator implements Component {
private Component component;
public Decorator(Component component) {
this.component = component;
}
public void operation() {
component.operation();
}
}
// 定义具体装饰类A
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
public void operation() {
super.operation();
System.out.println("为具体组件增加的新功能A");
}
}
// 定义具体装饰类B
public class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
public void operation() {
super.operation();
System.out.println("为具体组件增加的新功能B");
}
}
// 使用示例
public class DecoratorPatternExample {
public static void main(String[] args) {
Component component = new ConcreteComponent();
Decorator decoratorA = new ConcreteDecoratorA(component);
Decorator decoratorB = new ConcreteDecoratorB(decoratorA);
decoratorB.operation();
}
}
在这个示例中，抽象组件 Component 定义了操作方法 operation，具体组件 ConcreteComponent 实现了该方法。抽象装饰类 Decorator 继承了 Component 接口，并拥有一个 Component 成员变量，从而可以对其进行装饰。具体装饰类 ConcreteDecoratorA 和 ConcreteDecoratorB 分别继承了 Decorator 类，并实现了 operation 方法，在调用父类 operation 方法之后，增加了新的功能。
在示例中，我们先创建了一个 ConcreteComponent 对象，然后用 ConcreteDecoratorA 对其进行装饰，再用 ConcreteDecoratorB 对其进行二次装饰。最终，调用 decoratorB 的 operation 方法，会先调用 ConcreteComponent 的 operation 方法，然后输出新功能 A 和新功能 B。
注意，在实际使用中，可以根据需要定义更多的具体装饰类来扩展功能。
C#实现
以下是C#中装饰器模式的示例代码：
using System;
// 定义组件接口
interface IComponent {
void Operation();
}
// 具体组件类
class ConcreteComponent : IComponent {
public void Operation() {
Console.WriteLine("具体组件的操作");
}
}
// 装饰器抽象类
abstract class Decorator : IComponent {
protected IComponent component;
public Decorator(IComponent component) {
this.component = component;
}
public virtual void Operation() {
if (component != null) {
component.Operation();
}
}
}
// 具体装饰器A
class ConcreteDecoratorA : Decorator {
public ConcreteDecoratorA(IComponent component) : base(component) {}
public override void Operation() {
base.Operation();
Console.WriteLine("具体装饰器A的操作");
}
}
// 具体装饰器B
class ConcreteDecoratorB : Decorator {
public ConcreteDecoratorB(IComponent component) : base(component) {}
public override void Operation() {
base.Operation();
Console.WriteLine("具体装饰器B的操作");
}
}
// 客户端代码
class Client {
static void Main() {
// 创建具体组件对象
ConcreteComponent c = new ConcreteComponent();
// 对组件对象进行装饰
ConcreteDecoratorA decoratorA = new ConcreteDecoratorA(c);
ConcreteDecoratorB decoratorB = new ConcreteDecoratorB(decoratorA);
// 调用装饰后的方法
decoratorB.Operation();
// 等待用户输入
Console.Read();
}
}
在这个示例中，我们首先定义了组件接口 IComponent 和具体组件类 ConcreteComponent。然后定义了装饰器抽象类 Decorator，其中包含一个组件对象。具体的装饰器类 ConcreteDecoratorA 和 ConcreteDecoratorB 继承自 Decorator，并实现自己的装饰操作。最后，在客户端代码中，我们创建了具体组件对象，然后通过多次装饰后调用装饰后的方法。
需要注意的是，在装饰器模式中，所有的装饰器都实现了相同的抽象类，从而实现了相同的接口。这样，客户端代码可以透明地使用装饰后的对象，而不必关心具体的装饰器类型。
总结
装饰器模式是一种结构型设计模式，它允许在运行时动态地为对象添加功能，而无需通过继承来实现。该模式可以增强代码的灵活性和可扩展性，并且遵循开放/封闭原则。在装饰器模式中，一个对象包装另一个对象，从而实现了在不改变对象的结构的情况下为其添加行为。该模式的主要思想是将功能分层，使每个类只负责一种功能，从而简化类的设计。装饰器模式的缺点是增加了代码的复杂度和理解难度，同时也可能增加运行时的开销。在实现时，需要注意装饰器类和被装饰类之间的接口一致性，以便能够无缝地使用装饰器对象替换原始对象。