学习大话设计模式06_装饰模式

装饰模式（Decorator）：

动态地给一个对象添加一些额外的职责，就增加功能来说，装饰模式比生成子类更为灵活。

 1 /**
 2  * Component 是定义一个对象接口，可以给这些对象动态地添加职责
 3  * @author Monica
 4  *
 5  */
 6 public abstract class Component {
 7     public abstract void Operation();
 8 }
 9
10
11 /**
12  * ConcreteComponent 是定义了一个具体的对象，也可以给这个对象添加一些职责
13  * @author Administrator
14  *
15  */
16 public class ConcreteComponent extends Component{
17
18     @Override
19     public void Operation() {
20         System.out.println("具体对象的操作");
21     }
22 }
23
24 /**
25  * Decorator 装饰抽象类，继承了Component，从扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的
26  * @author Administrator
27  *
28  */
29 public class Decorator extends Component {
30     private Component component;
31
32     //设置Component
33     public void setComponent(Component component) {
34         this.component = component;
35     }
36
37     @Override
38     public void Operation() {
39         //重写Operation(), 实际执行的是Component的Operation()
40         if(component != null) {
41             component.Operation();
42         }
43     }
44
45 }
46
47 class ConcreteDecoratorA extends Decorator {
48     //本类的独有功能，以区别于ConcreteDecoratorB
49     private String addedState;
50
51     @Override
52     public void Operation() {
53         //首先运行原Component的Operation()，再执行本类的功能，如addedState，相当于对原Component进行了装饰
54         super.Operation();
55         addedState = "New State";
56         System.out.println("具体装饰对象A的操作");
57     }
58 }
59
60 class ConcreteDecoratorB extends Decorator {
61
62     @Override
63     public void Operation() {
64         //首先运行原Component的Operation()，再执行本类的功能，如addedState，相当于对原Component进行了装饰
65         super.Operation();
66         AddedBehavior();
67         System.out.println("具体装饰对象B的操作");
68     }
69
70     private void AddedBehavior() {
71
72     }
73 }

执行方法：

public static void main(String[] args) {
        ConcreteComponent c = new ConcreteComponent();
        ConcreteDecoratorA d1 = new ConcreteDecoratorA();
        ConcreteDecoratorB d2 = new ConcreteDecoratorB();
        /*
         * 装饰的方法是：
         * 首先用ConcreteComponent实例化对象c，
         * 然后用ConcreteDecoratorA的实例化对象d1来包装c，
         * 再用ConcreteDecoratorB的对象d2包装d1，
         * 最后执行d2的Operation()
         */
        d1.setComponent(c);
        d2.setComponent(d1);
        d2.Operation();
}

装饰模式是利用SetComponent来对对象进行包装的，这样每个装饰对象的实现就和如何使用这个对象分离开了，每个装饰对象只关心自己的功能，不需要关心如何被添加到对象链当中。

如何只有一个ConcreteComponent类而没有抽象的Component类，那么Decorator类可以是ConcreteComponent的一个子类。同样道理，如果只有一个ConcreteDecorator类，那么就没有必要建立一个单独的Decorator类，而可以把Decorator和ConcreteDecorator的责任合并成一个类。

/**
 * Person类（ConcreteComponent）
 * @author Administrator
 *
 */
class Person {
    public Person() {

    }

    private String name;

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

    public void Show() {
        System.out.println("装扮的" + name);
    }
}

/**
 * 服饰类(Decorator)
 * @author Administrator
 *
 */
class Finery extends Person {
    protected Person component;

    //打扮
    public void Decorate(Person component) {
        this.component = component;
    }

    @Override
    public void Show() {
        if(component != null) {
            component.Show();
        }
    }
}

/**
 * 具体服饰类（ConcreteDecorator）
 * @author Administrator
 *
 */
class TShirts extends Finery {

    @Override
    public void Show() {
        System.out.println("大T恤");
        super.Show();
    }
}

class BigTrouser extends Finery {

    @Override
    public void Show() {
        System.out.println("垮裤");
        super.Show();
    }
}

//其余类类似，省略

调用方法：

public static void main(String[] args) {
        Person xc = new Person("小菜");

        BigTrouser kk = new BigTrouser();
        TShirts dtx = new TShirts();

        kk.Decorate(xc);
        dtx.Decorate(kk);
        dtx.Show();
    }

学习大话设计模式06_装饰模式