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

装饰模式（Decorator）：

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

 

/**
 * Component 是定义一个对象接口，可以给这些对象动态地添加职责
 * @author Monica
 *
 */
public abstract class Component {
    public abstract void Operation();
}


/**
 * ConcreteComponent 是定义了一个具体的对象，也可以给这个对象添加一些职责
 * @author Administrator
 *
 */
public class ConcreteComponent extends Component{

    @Override
    public void Operation() {
        System.out.println("具体对象的操作");
    }
}

/**
 * Decorator 装饰抽象类，继承了Component，从扩展Component类的功能，但对于Component来说，是无需知道Decorator的存在的
 * @author Administrator
 *
 */
public class Decorator extends Component {
    private Component component;
    
    //设置Component
    public void setComponent(Component component) {
        this.component = component;
    }
    
    @Override
    public void Operation() {
        //重写Operation(), 实际执行的是Component的Operation()
        if(component != null) {
            component.Operation();
        }
    }
 
}

class ConcreteDecoratorA extends Decorator {
    //本类的独有功能，以区别于ConcreteDecoratorB
    private String addedState;
    
    @Override
    public void Operation() {
        //首先运行原Component的Operation()，再执行本类的功能，如addedState，相当于对原Component进行了装饰
        super.Operation();
        addedState = "New State";
        System.out.println("具体装饰对象A的操作");
    }
}

class ConcreteDecoratorB extends Decorator {
    
    @Override
    public void Operation() {
        //首先运行原Component的Operation()，再执行本类的功能，如addedState，相当于对原Component进行了装饰
        super.Operation();
        AddedBehavior();
        System.out.println("具体装饰对象B的操作");
    }

    private void AddedBehavior() {
        
    }
}

执行方法：

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