Java设计模式-装饰模式

Posted 2023-05-16 xstxjs

简介

装饰模式在Java领域是一种常见的设计模式，它能够在不改变对象原有结构的情况下，动态地为对象添加新的功能。它通过封装原有对象，在运行时动态地为对象添加新的行为或者修改原有行为，以扩展对象的功能。这种方式避免了继承的静态特性，让对象的行为可以根据需要进行动态变化。在装饰模式中，通常会有一个装饰器类，该类继承自要被装饰的对象，然后在运行时为对象添加新的功能。
在设计模式中，装饰模式与其他几种常见的设计模式有一些相似之处，例如适配器模式、代理模式和桥接模式。这些模式都是为了改变对象的行为而提供了解决方案，但它们与装饰模式的主要区别在于：

1. 适配器模式：适配器模式用于连接两个不兼容的接口。它将一个类的接口转换为另一个接口，以适应另一个类的需求。适配器模式通常在应用程序中解决不兼容的接口问题。

2. 代理模式：代理模式用于控制对对象的访问。它允许在不改变对象的结构的情况下控制对对象的访问，以提供安全性和性能方面的好处。代理模式通常用于实现远程对象访问、访问控制和缓存等功能。

3. 桥接模式：桥接模式用于将一个抽象类与多个实现类解耦。它将一个抽象类与多个实现类分离开来，以使它们可以独立地进行修改和扩展。桥接模式通常用于实现可扩展的类层次结构。

实现

现在，我们来看看如何使用Java编程语言实现装饰模式。

首先，我们需要定义一个接口或者抽象类来定义要被装饰的对象。例如，我们可以定义一个抽象类Component，它包含一个抽象方法operation()，表示该对象的操作。具体实现可以根据业务需求进行扩展。

public abstract class Component 
    public abstract void operation();

然后，我们需要定义具体的对象类，实现Component接口或者继承Component抽象类。例如，我们可以定义一个具体的对象类ConcreteComponent，它实现了Component接口，实现了operation()方法。

public class ConcreteComponent extends Component 
    @Override
    public void operation() 
        System.out.println("执行具体对象的操作");
    

接下来，我们需要定义一个装饰器类Decorator，它继承自Component类，并包含一个Component类型的成员变量，表示要被装饰的对象。它的构造函数可以接收一个Component类型的参数，用于初始化成员变量。

public class Decorator extends Component 
    private Component component;

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

    @Override
    public void operation() 
        component.operation();
    

最后，我们可以定义具体的装饰器类，它继承自Decorator类，并扩展了要被装饰的对象的功能。例如，我们可以定义一个具体的装饰器类ConcreteDecorator，它添加了新的功能，例如在原有操作前或者后输出一些信息。

public class ConcreteDecorator extends Decorator 
    public ConcreteDecorator(Component component) 
        super(component);
    

    @Override
    public void operation() 
        System.out.println("添加新的功能");
        super.operation();
    

现在，我们就可以使用装饰模式来扩展对象的功能了。例如，我们可以创建一个具体对象component，然后用装饰器类ConcreteDecorator来装饰它，以添加新的功能。

Component component = new ConcreteComponent();
Component decorator = new ConcreteDecorator(component);
decorator.operation();

在运行以上代码后，我们可以看到控制台输出了以下信息：

添加新的功能
执行具体对象的操作

优缺点

优点

1. 装饰模式可以动态地为对象添加新的功能，而不需要修改原有的代码。这种方式可以让代码更加灵活和可扩展。
2. 装饰模式避免了继承的缺点，例如类层次结构的膨胀和代码的复杂性，使得代码更加简洁和易于维护。
3. 装饰模式可以嵌套使用，以实现更加复杂的功能。

缺点

1. 装饰模式增加了代码的复杂性，需要增加许

多的类和对象，这可能会使代码难以理解和维护。

2. 装饰模式增加了系统的运行时开销，因为每个装饰器都要增加一些额外的处理。

运用场景

1. 当需要动态地为对象添加新的功能时，可以考虑使用装饰模式。
2. 当不希望使用继承来扩展对象的功能时，可以考虑使用装饰模式。
3. 当需要在不修改原有代码的情况下，增加一些新的功能时，可以考虑使用装饰模式。

总结

装饰模式是一种非常有用的设计模式，它可以动态地为对象添加新的功能，而不需要修改原有的代码。通过定义一个抽象的装饰器类和具体的装饰器类，我们可以非常方便地扩展对象的功能，以满足不同的业务需求。虽然装饰模式增加了代码的复杂性和运行时开销，但是它在许多情况下仍然是一种非常有效的解决方案。

Java设计模式——装饰者模式

一.定义

装饰者模式（Decorator Pattern）：动态的给一个对象添加新的功能，同时又不改变其结构。又叫装饰器模式

若要扩展功能，装饰者模式提供了比继承更有弹性的替代方案

二.装饰者模式的角色

抽象构件(Component)角色：是一个抽象类或者接口，是要装饰原始对象

具体构件(ConcreteComponent)角色：要装饰的实际对象

装饰(Decorator)角色：是一个抽象类，继承和实现Component接口，同时拥有一个对Component实例对象的引用，也可以有自己的方法

具体装饰(ConcreteDecorator)角色：具体的装饰者，负责给ConcreteComponent动态的增加新功能。

UML图

 

 

三.示例

 1 /**
 2  *  抽象构件角色： 要装饰的原始角色
 3  */
 4 public abstract class Component {
 5     public abstract void operate();
 6 }
 7 
 8 /**
 9  *  需要被装饰对象的实现类
10  */
11 public class ConcreteComponent extends Component {
12     @Override
13     public void operate() {
14         System.out.println("ConcreteComponent 实际要被装饰的对象");
15     }
16 }
17 
18 /**
19  *  1.抽象的装饰器类继承或者实现抽象组件类
20  *  2.拥有一个对组件类的引用
21  */
22 public abstract class Decorator extends Component {
23     private Component component;
24 
25     public Decorator(Component component) {
26         this.component = component;
27     }
28 
29     @Override
30     public void operate() {
31         // 调用装饰者方法
32         component.operate();
33     }
34 }
35 /**
36   *  实际装饰者A
37   *
38   */
39 public class ConcreteDecoratorA extends Decorator {
40 
41     public ConcreteDecoratorA(Component component) {
42         super(component);
43     }
44 
45     @Override
46     public void operate() {
47         super.operate();
48         operateAMethod();
49     }
50 
51     public void operateAMethod(){
52         System.out.println("ConcreteDecoratorA 自己的方法");
53     }
54 }
55 
56 /**
57  *  实际装饰者B
58  */
59 public class ConcreteDecoratorB extends Decorator {
60     public ConcreteDecoratorB(Component component) {
61         super(component);
62     }
63 
64     @Override
65     public void operate() {
66         super.operate();
67         operateBMethod();
68     }
69 
70     public void operateBMethod(){
71         System.out.println("ConcreteDecoratorB 自己的方法");
72     }
73 }

测试结果：

1         Component component = new ConcreteComponent();
2         Component componentA = new ConcreteDecoratorA(component);
3         Component componentB = new ConcreteDecoratorB(component);
4         componentA.operate();
5         componentB.operate();

 

 

透明的装饰者和半透明的装饰者

透明的装饰者：要求具体的构建角色、装饰者接口与抽象构建角色的接口一致，这种在使用的时候两种类型没有区别，都是继承或者实现了抽象构建角色， 方法的接口也是完全相同的，可以通过抽象类型的引用去操作，对外是透明的，这种是理想的模式

半透明的装饰者： 如果装饰角色的接口与抽象构建角色的接口不一致，也就是说装饰角色的接口宽一些，装饰角色实际上已经成了一个适配器，这种属于半透明的装饰者模式，这种模式下子类可以有自己的个性化方法。

四.装饰者模式在实际中的应用

1.jdk中的应用

输入流 输出流 字符流 都涉及装饰者模式，每个嵌套层都有自己的特性

1 OutputStream outputStream = new BufferedOutputStream(new FileOutputStream(new File("user.txt")));
2         InputStream inputStream = new DataInputStream(new BufferedInputStream(new FileInputStream(new File("reader.txt"))));

 

 

 

 

 

五.适用场景及优缺点

使用场景：

扩展一个类的功能或者给一个类添加附加职责

优点：

继承的有力补充，比继承灵活，在不改变原有对象的基础上给一个对象扩展新的功能

通过使用不同的装饰类或者这些装饰类的排列组合，可以实现不同效果

符合开闭原则

缺点：

会出现很多装饰类，增加代码复杂性

状态装饰时，多层装饰时会更复杂