设计模式--装饰器模式

设计模式--装饰器模式

1 概述

---

1.1 定义
装饰器模式(Decorator Design)动态的扩展一个对象的功能。论扩展功能而言，装饰器提供了比继承更有弹性的替代方案。

1.2 应用
JDK中的java.io包就使用的装饰器来扩展IO接口。

1.2 类图

 

1. Component抽象组件角色：定义我们最核心的抽象对象。
2. ConcreteComponent具体组件角色：定义最核心抽象对象的实现，你要装饰的对象就是它。
3. Decorator装饰角色：装饰的抽象对象，其有一个私有的变量指向Component抽象组件。
4. ConcreteDecorator具体装饰角色：具体的装饰对象，用来装饰组件。

2 详解

---

Component 抽象构件

public abstract class Component {
    // 抽象方法
    public abstract void operate();
}

ConcreteComponent 具体构件-->你要装饰的具体对象

public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        System.out.println("ConcreteComponent.operate()");
    }
}

Decorator 抽象的装饰者-->需要接受一个具体的需要被装饰的对象

public abstract class Decorator extends Component {
    private Component component;

    // 通过构造函数传递被装饰者
    Decorator(Component component) {
        this.component = component;
    }

    // 委托被装饰者执行
    @Override
    public void operate() {
        component.operate();
    }
}

ConcreteDecoratorA、ConcreteDecoratorB 具体的装饰者

public class ConcreteDecoratorA extends Decorator {
    // 定义被被装饰者
    ConcreteDecoratorA(Component component) {
        super(component);
    }

    // 重写父类的operate方法, 以用来定义自己的装饰行为
    @Override
    public void operate() {
        System.out.println("ConcreteDecoratorA do some operate");
        super.operate();
    }
}

public class ConcreteDecoratorB extends Decorator {
    // 定义被装饰者
    ConcreteDecoratorB(Component component) {
        super(component);
    }
    // 重写父类的operate方法，以用来定义自己的装饰行为
    @Override
    public void operate() {
        System.out.println("ConcreteDecoratorB do some operate");
        super.operate();
    }
}

测试

public class Client {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        component.operate();
        System.out.println("-------------------------------------");
        // 使用ConcreteDecoratorA装饰原对象
        Component component1 = new ConcreteDecoratorA(component);
        component1.operate();
        System.out.println("-------------------------------------");
        // 使用ConcreteDecoratorB装饰原对象
        Component component2 = new ConcreteDecoratorB(component);
        component2.operate();
        System.out.println("-------------------------------------");
        // 先使用ConcreteDecoratorA装饰对象，再使用ConcreteDecoratorB装饰对象
        Component component3 = new ConcreteDecoratorB(new ConcreteDecoratorA(component));
        component3.operate();
    }
}output:
ConcreteComponent.operate()
-------------------------------------
ConcreteDecoratorA do some operate
ConcreteComponent.operate()
-------------------------------------
ConcreteDecoratorB do some operate
ConcreteComponent.operate()
-------------------------------------
ConcreteDecoratorB do some operate
ConcreteDecoratorA do some operate
ConcreteComponent.operate()

3 应用

java.io类包中就是使用了装饰器设计模式来装饰，避免过多的使用继承，但也造成了API繁琐。

自己写的IO装饰者--->UpperCaseInputStream(小写字符转换成大写字符)

public class UpperCaseInputStream extends FilterInputStream {

    protected UpperCaseInputStream(InputStream in) {
        super(in);
    }

    public int readCharToUpperCase() throws IOException {
        int c = read();
        return c == -1 ? c : Character.toUpperCase(c);
    }
}

public class Client {
    public static void main(String[] args) throws Exception {
        UpperCaseInputStream in = new UpperCaseInputStream(
                new BufferedInputStream(new FileInputStream("E:\\java\\America.java")));
        int c;
        while((c = in.readCharToUpperCase()) != -1) {
            System.out.print((char) c);
        }
    }
}