Java设计模式07：常用设计模式之装饰器模式（结构型模式）

1. Java之装饰器模式（Decorator Pattern）

（1）概述：

    装饰模式在Java种使用也很广泛，比如我们在重新定义按钮、对话框等时候，实际上已经在使用装饰模式了。在不必改变原类文件和使用继承的情况下，装饰模式使用一种对客户端透明的方式来动态地扩展对象的功能，同时它也是继承关系的一种替代方案之一，它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

    装饰者模式：动态地给一个对象添加一些额外的职责，就像在墙上刷油漆一样。就增加功能来说，Decorator模式比生成子类更为灵活。

　 Decorator模式的工作原理是：可以创建始于Decorator对象（负责新的功能的对象）终于原对象的一个对象"链"

                       

　　　　　　　　　　　　　　　　　　　　　　　　图1  装饰者链

装饰模式的特点：

　　• 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。

　　• 装饰对象包含一个真实对象的引用（reference）

　　• 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。

　　• 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。

 

（2）装饰模式的UML类图：

抽象组件角色(Component)：定义一个对象接口，以规范准备接受附加责任的对象，即可以给这些对象动态地添加职责。

具体组件角色(ConcreteComponent) ：被装饰者，定义一个将要被装饰增加功能的类。可以给这个类的对象添加一些职责

抽象装饰器(Decorator)：维持一个指向构件Component对象的实例，并定义一个与抽象组件角色Component接口一致的接口

具体装饰器角色（ConcreteDecorator)：向组件添加职责。

 

（3）下面是装饰者模式通用模式代码：

/******************抽象组件类**************/
public abstract class Component {
    /**
    * 抽象的方法,这个随你做
    * 同样第你也可以增加更多的抽象方法
    */
    public abstract void operate();
}


/******************组件具体实现类**************/
public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        //具体逻辑，这个随你做
    }
}


/******************抽象装饰者**************/
public abstract class Decorator extends Component {
    private Component component;//持有一个Component对象的引用
    /*
    *必要的构造方法 需要一个Component类型的对象
    *
    * @param component Component对象
    */
    public Decorator(Component component) {
        this.component = component;
    }
    
    @Override
    public void operate() {
        component.operate();
    }
    
}


/******************装饰者具体实现类A**************/
public class ConcreteDecoratorA extends Decorator {
    protected ConcreteDecoratorA(Component component) {
        super(component);
    }
    
    @Override
    public void operate() {
        //装饰方法A和B既可在父类方法前调用也可在之后调用
        operateA();
        
        super.operate();
        
        operateB();
    }
    
    /**
    * 自定义的装饰方法A
    */
    public void operateA() {
        //装饰方法的逻辑
    }
    
    /**
    * 自定义的装饰方法B
    */
    public void operateB() {
        //装饰方法的逻辑
    }
}

/******************装饰者具体实现类B**************/
public class ConcreteDecoratorB extends Decorator {
    
    protected ConcreteDecoratorB(Component component) {
        super(component);
    }
    
    @Override
    public void operate() {
        //装饰方法A和B既可在父类方法前调用也可在之后调用
        operateA();
        
        super.operate();
        
        operateB();
    }
    
    /**
    * 自定义的装饰方法A
    */
    public void operateA() {
        //装饰方法的逻辑
    }
    
    /**
    * 自定义的装饰方法B
    */
    public void operateB() {
        //装饰方法的逻辑
    }
}


/******************客户调用类**************/
public class Client {
    public static void main(String[] args) {
        //构建被装饰的组件对象
        Component component = new Component();
        
        //根据组件对象构建装饰者对象A并调用，此时相当于给组件对象增加装饰者A的功能方法
        Decorator decorator = new ConcreteDecoratorA(component);
        decorator.operate();
        
        //根据组件对象构建装饰者对象B并调用，此时相当于给组件对象增加装饰者B的功能方法
        Decorator decoratorB = new ConcreteDecoratorB(component);
        decoratorB.operate();
    }
}

 

 

 

2. 装饰器模式简单实现：

人需要各式各样的衣着，不管你穿着怎么样，但是，对于个人的本质来说是不可变的，充其量只是在外面披上一层遮羞物。

（1）人总是需要穿衣服的，我们这里将人定义一个抽象类，将穿衣的行为定义一个抽象方法：

抽象组件类：

public abstract class Person {
    /**
    * Person 下有一个穿着的抽象方法
    */
    
    public abstract void dressed();
}

 

（2）接下来我们需要具体装饰谁呢? 也就是说我们需要创建一个具体组件类，如下：

具体组件类：

public class Boy extends Person {
    
    @Override
    public void dressed() {
        //Boy 类下dressed方法的基本逻辑
        System.out.println("穿了内衣内裤");
    }
}

 

 

（3）上面的Boy类就是我们所要装饰的具体对象，现在需要一个装饰者来装饰我们的这个Boy对象，这里定义一个PersonCloth类来表示人所穿着的衣服

抽象装饰者类：

public abstract class PersonCloth extends Person {
    protected Person mPerson;//保持一个Person类的引用
    
    public PersonCloth(Person mPerson) {
        this.mPerson = mPerson;
    }
    
    @Override
    public void dressed() {
        //调用Person类中的dressed方法
        
        mPerson.dressed();
    }
}

在PersonCloth类中我们保持一个对Person的引用，这样就可以方便地调用具体被装饰对象中的方法，这也是为什么我们可以在不破坏原类层次结构的情况下为类增加一些功能，我们只需要在被装饰对象的相应方法前 或者 后 增加相应的功能逻辑即可。

 

（4）定义两种装饰具体实现类，如下：

装饰具体实现类之 高档衣服：

public class ExpensiveCloth extends PersonCloth {
    public ExpensiveCloth(Person person) {
        super(person);
    }
    
    
    
    //穿短袖
    private void dressShirt() {
        System.out.println("穿件短袖");
    }
    
    //穿皮衣
    private void dressLeather(){
        System.out.println("穿件皮衣");
    }
    
    //穿牛仔裤
    private void dressJean(){
        System.out.println("穿牛仔裤");
    }
    
    
    @Override
    public void dressed() {
        super.dressed();
        
        dressShirt();
        dressLeather();
        dressJean();
    }
    
}

装饰具体实现类之 便宜的衣服：

public class CheapCloth extends PersonCloth {
    
    public CheapCloth(Person mPerson) {
        super(mPerson);
    }
    
    
    //穿短袖
    private void dressShorts() {
        System.out.println("穿件短袖");
    }
    
    
    @Override
    public void dressed() {
        super.dressed();
        
        dressShorts();
    }
}

 

 

（5）客户端类：

public class Main {
    
    public static void main(String[] args) {
        //首先我们要有一个Person男孩
        Person person = new Boy();
        
        //然后为他穿上便宜的衣服，比如爱哥这样的Boy
        PersonCloth clothCheap = new CheapCloth(person);
        clothCheap.dressed();
        
        //或者给他穿上比较上档次的衣服，如SM
        PersonCloth clothExpensive = new ExpensiveCloth(person);
        clothExpensive.dressed();
    }
    
}