装饰器模式是一种结构性设计模式,它允许你在运行时动态地扩展一个对象的功能。在装饰器模式中,你可以将一个对象包装在另一个对象中,从而给这个对象添加新的行为或责任。下面是一个 Java 实现的示例:
第一个实现
假设我们有一个抽象类Shape
,它定义了一个方法draw
,它将在具体的形状类中实现。
public abstract class Shape {
public abstract void draw();
}
现在我们需要添加一个新的行为,即给形状添加边框。我们可以使用装饰器模式来实现这个功能。
首先,我们创建一个抽象的装饰器类ShapeDecorator
,它扩展了Shape
类,并将其构造函数的参数设置为Shape
对象。
public abstract class ShapeDecorator extends Shape {
protected Shape decoratedShape;
public ShapeDecorator(Shape decoratedShape) {
this.decoratedShape = decoratedShape;
}
public void draw() {
decoratedShape.draw();
}
}
接下来,我们创建一个具体的装饰器类BorderDecorator
,它扩展了ShapeDecorator
类,并在draw
方法中添加了边框的逻辑。
public class BorderDecorator extends ShapeDecorator {
public BorderDecorator(Shape decoratedShape) {
super(decoratedShape);
}
public void draw() {
decoratedShape.draw();
setBorder(decoratedShape);
}
private void setBorder(Shape decoratedShape){
System.out.println("Adding Border to Shape");
}
}
现在,我们可以创建具体的形状类,例如Circle
和Rectangle
。
public class Circle extends Shape {
public void draw() {
System.out.println("Shape: Circle");
}
}
public class Rectangle extends Shape {
public void draw() {
System.out.println("Shape: Rectangle");
}
}
最后,我们可以使用装饰器模式将BorderDecorator
对象包装在Circle
和Rectangle
对象中,从而给这些对象添加边框行为。
Shape circle = new Circle();
Shape rectangle = new Rectangle();
Shape circleWithBorder = new BorderDecorator(new Circle());
Shape rectangleWithBorder = new BorderDecorator(new Rectangle());
circle.draw();
rectangle.draw();
circleWithBorder.draw();
rectangleWithBorder.draw();
输出:
Shape: Circle
Shape: Rectangle
Shape: Circle
Adding Border to Shape
Shape: Rectangle
Adding Border to Shape
在这个示例中,我们通过装饰器模式成功地为形状添加了新的行为,而不需要修改原始的形状类。
第二个实现案例
首先定义一个接口,它表示将要被装饰的对象:
public interface Component {
void operation();
}
然后定义一个具体的实现类:
public class ConcreteComponent implements Component {
@Override
public void operation() {
System.out.println("ConcreteComponent.operation() called.");
}
}
接下来定义一个抽象装饰器类,它持有一个 Component 对象,并且与 Component 有相同的接口:
public abstract class Decorator implements Component {
protected Component component;
public Decorator(Component component) {
this.component = component;
}
@Override
public void operation() {
component.operation();
}
}
然后定义具体的装饰器类,它通过继承装饰器类并添加额外的行为来实现装饰:
public class ConcreteDecoratorA extends Decorator {
public ConcreteDecoratorA(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addBehavior();
}
private void addBehavior() {
System.out.println("ConcreteDecoratorA.addBehavior() called.");
}
}
public class ConcreteDecoratorB extends Decorator {
public ConcreteDecoratorB(Component component) {
super(component);
}
@Override
public void operation() {
super.operation();
addBehavior();
}
private void addBehavior() {
System.out.println("ConcreteDecoratorB.addBehavior() called.");
}
}
最后,在客户端代码中使用装饰器模式:
public class Client {
public static void main(String[] args) {
Component component = new ConcreteComponent();
component = new ConcreteDecoratorA(component);
component = new ConcreteDecoratorB(component);
component.operation();
}
}
输出结果为:
ConcreteComponent.operation() called.
ConcreteDecoratorA.addBehavior() called.
ConcreteDecoratorB.addBehavior() called.
可以看到,通过装饰器模式,我们成功地将行为动态地添加到对象中,同时保持了对象的接口不变。这种模式可以在运行时动态地添加和删除装饰器,从而对对象进行细粒度的控制。