Java设计模式之Builder和Decorator

                                           Java设计模式

                                      之

                           Builder和Decorator

1、建造者模式(Builder)

工厂类模式提供的是创建单个类的模式，而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码：

一个Sender接口，两个实现类MailSender和SmsSender。最后，建造者类如下：

 

1.  public class Builder {  

2.       

3.      private List<Sender> list = new ArrayList<Sender>();  

4.       

5.      public void produceMailSender(int count){  

6.         for(int i=0; i<count; i++){  

7.              list.add(new MailSender());  

8.         }  

9.      }  

10.      

11.     public void produceSmsSender(int count){  

12.        for(int i=0; i<count; i++){  

13.             list.add(new SmsSender());  

14.        }  

15.     }  

16.} 

 

测试类：

1.  public class Test {  

2.      public static void main(String[] args) {  

3.         Builder builder = new Builder();  

4.          builder.produceMailSender(10);  

5.     }  

6.  }  

 

从这点看出，建造者模式将很多功能集成到一个类里，这个类可以创造出比较复杂的东西。所以与工程模式的区别就是：工厂模式关注的是创建单个产品，而建造者模式则关注创建符合对象，多个部分。因此，是选择工厂模式还是建造者模式，依实际情况而定。

2、装饰模式(decorator)

顾名思义，装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例，关系图如下：

Source类是被装饰类，Decorator类是一个装饰类，可以为Source类动态的添加一些功能，代码如下：

定义一个Sourceable接口，并在里面定义某个方法。

1.  public interface Sourceable {  

2.     public void method();  

3.  } 

 

创建一个Source类并实现Sourceable接口。

1.  public class Source implements Sourceable {  

2.      @Override  

3.     public void method() {  

4.          System.out.println("the original method!");  

5.     }  

6.  } 

 

创建一个Decorator类，它也实现了Sourceable接口。并且有一个带参的构造函数，参数就是Sourceable接口。

1.  public class Decorator implements Sourceable {  

2.   

3.      private Sourceable source; 

4.      public Decorator(Sourceable source){  

5.         super();  

6.          this.source = source;  

7.     }  

8.      @Override  

9.     public void method() {  

10.         System.out.println("before decorator!");  

11.        source.method();  

12.         System.out.println("after decorator!");  

13.    }  

14. }  

 

测试类：

1.  public class DecoratorTest {  

2.   

3.      public static void main(String[] args) {  

4.         Sourceable source = new Source();  

5.          Sourceable obj = new Decorator(source);  

6.         obj.method();  

7.      }  

8. } 

输出：

before decorator!
the original method!
after decorator!

装饰器模式的应用场景：

1、需要扩展一个类的功能。

2、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

缺点：产生过多相似的对象，不易排错！