装饰者模式

ps :这个模式和直接子类chilidClass 重写父类parentClass的方法 methodA 很像，只不过

利用一个装饰类 来修改 childClass 里面methoadA方法  

以下转载：

实例1 

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。
 适用性
 
1.在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。
 
    2.处理那些可以撤销的职责。
 
    3.当不能采用生成子类的方法进行扩充时。
                       
 参与者
    1.Component
      抽象构件角色: 定义一个对象接口，可以给这些对象动态地添加职责。
 
    2.ConcreteComponent
      具体构件角色: 定义一个对象，可以给这个对象添加一些职责。
 
    3.Decorator
      持有一个Component对象的实例，并定义一个与Component接口一致的接口。
    4.ConcreteDecorator
      向组件添加职责。
 类图

 例子
Component
 
public interface Person {
 
    void eat();
}
ConcreteComponent
 
public class Man implements Person {
 
        public void eat() {
               System.out.println("男人在吃");
        }
}
Decorator
 
public abstract class Decorator implements Person {
 
    protected Person person;
    
    public void setPerson(Person person) {
        this.person = person;
    }
    
    public void eat() {
        person.eat();
    }
}
ConcreteDec*rator
 
public class ManDecoratorA extends Decorator {
 
    public void eat() {
        super.eat();
        reEat();
        System.out.println("ManDecoratorA类");
    }
 
    public void reEat() {
        System.out.println("再吃一顿饭");
    }
}
 
public class ManDecoratorB extends Decorator {
    
    public void eat() {
        super.eat();
        System.out.println("===============");
        System.out.println("ManDecoratorB类");
    }
}
Test
 
public class Test {
 
    public static void main(String[] args) {
        Man man = new Man();
        ManDecoratorA md1 = new ManDecoratorA();
        ManDecoratorB md2 = new ManDecoratorB();
        
        md1.setPerson(man);
        md2.setPerson(md1);
        md2.eat();
    }
}
result
 
男人在吃
再吃一顿饭
ManDecoratorA类
===============
ManDecoratorB类

实例2 

7、装饰模式（Decorator）
顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，关系图如下：
Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：
 

  

   

    [java] 
    view plain
    copy
   
  
  
public interface Sourceable {  
    public void method();  
}  
 
 

  

   

    [java] 
    view plain
    copy
   
  
  
public class Source implements Sourceable {  
  
    @Override  
    public void method() {  
        System.out.println("the original method!");  
    }  
}  
 
 

  

   

    [java] 
    view plain
    copy
   
  
  
public class Decorator implements Sourceable {  
  
    private Sourceable source;  
      
    public Decorator(Sourceable source){  
        super();  
        this.source = source;  
    }  
    @Override  
    public void method() {  
        System.out.println("before decorator!");  
        source.method();  
        System.out.println("after decorator!");  
    }  
}  
 
测试类：
 

  

   

    [java] 
    view plain
    copy
   
  
  
public class DecoratorTest {  
  
    public static void main(String[] args) {  
        Sourceable source = new Source();  
        Sourceable obj = new Decorator(source);  
        obj.method();  
    }  
}  
 
输出：
before decorator!
the original method!
after decorator!
装饰器模式的应用场景：
1、需要扩展一个类的功能。
2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）
缺点：产生过多相似的对象，不易排错！