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

 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();
}

/**
 * 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();
    }