Java设计模式之Builder和Decorator

                                           Java设计模式

                                       之

                           Builder和Decorator

1、建造者模式(Builder)

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

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

 

1.  public class Builder {  

2.        

3.      private List list = new ArrayList();  

4.        

5.      public void produceMailSender(int count){  

6.          for(int i=0; i

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

8.          }  

9.      }  

10.       

11.     public void produceSmsSender(int count){  

12.         for(int i=0; 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、动态的为一个对象增加功能，而且还能动态撤销。（继承不能做到这一点，继承的功能是静态的，不能动态增删。）

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