欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

讲解Java设计模式编程中的建造者模式与原型模式

程序员文章站 2024-03-08 14:23:40
建造者模式 定义 又叫生成器模式,它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。 当创建复杂对象的算法...

建造者模式
定义
又叫生成器模式,它可以将复杂对象的建造过程抽象出来(抽象类别),使这个抽象过程的不同实现方法可以构造出不同表现(属性)的对象。

当创建复杂对象的算法应该独立于该对象的组成部分时,而且构造过程必须允许被构造的对象有不同的表示时。我们可以考虑使用建造者模式。

实现

讲解Java设计模式编程中的建造者模式与原型模式

 

1. builder为创建一个product对象的各个部件指定抽象接口。通常包含创建产品和返回产品的抽象方法,也可以是具体方法,把创建过程放到concretebuilder类中。
2. concretebuilder 实现builder的接口以构造和装配该产品的各个部件。
3. director负责调用适当的建造者来组建产品,导演类一般不与产品类发生依赖关系,与导演类直接交互的是建造者类。
4. product表示被构造的复杂对象。concreatebuilder创建该产品的内部表示并定义它的装配过程。

/** "product" */ 
 class pizza { 
  private string dough = ""; 
  private string sauce = ""; 
  private string topping = ""; 
  
  public void setdough (string dough)   { this.dough = dough; } 
  public void setsauce (string sauce)   { this.sauce = sauce; } 
  public void settopping (string topping) { this.topping = topping; } 
 } 
  
  
 ''/** "abstract builder" */'' 
 abstract class pizzabuilder { 
  protected pizza pizza; 
  
  public pizza getpizza() { return pizza; } 
  public void createnewpizzaproduct() { pizza = new pizza(); } 
  
  public abstract void builddough(); 
  public abstract void buildsauce(); 
  public abstract void buildtopping(); 
 } 
  
 /** "concretebuilder" */ 
 class hawaiianpizzabuilder extends pizzabuilder { 
  public void builddough()  { pizza.setdough("cross"); } 
  public void buildsauce()  { pizza.setsauce("mild"); } 
  public void buildtopping() { pizza.settopping("ham+pineapple"); } 
 } 
  
 /** "concretebuilder" */ 
 class spicypizzabuilder extends pizzabuilder { 
  public void builddough()  { pizza.setdough("pan baked"); } 
  public void buildsauce()  { pizza.setsauce("hot"); } 
  public void buildtopping() { pizza.settopping("pepperoni+salami"); } 
 } 
  
  
 ''/** "director" */'' 
 class waiter { 
  private pizzabuilder pizzabuilder; 
  
  public void setpizzabuilder (pizzabuilder pb) { pizzabuilder = pb; } 
  public pizza getpizza() { return pizzabuilder.getpizza(); } 
  
  public void constructpizza() { 
   pizzabuilder.createnewpizzaproduct(); 
   pizzabuilder.builddough(); 
   pizzabuilder.buildsauce(); 
   pizzabuilder.buildtopping(); 
  } 
 } 
  
 /** a customer ordering a pizza. */ 
 class builderexample { 
  public static void main(string[] args) { 
   waiter waiter = new waiter(); 
   pizzabuilder hawaiian_pizzabuilder = new hawaiianpizzabuilder(); 
   pizzabuilder spicy_pizzabuilder = new spicypizzabuilder(); 
  
   waiter.setpizzabuilder ( hawaiian_pizzabuilder ); 
   waiter.constructpizza(); 
  
   pizza pizza = waiter.getpizza(); 
  } 
 } 

客户创建director对象,并用它所想要的builder对象进行配置。director取得客户的请求创建产品,最后取得产品。

优点
1. 可以对构造对象的过程进行精细的控制,以产生不同的产品对象。
2. 便于扩展,有新的产品时,只需增加新的concretebuilder 就可以实现。

相关模式
抽象工厂模式与生成器相似,因为它也可以创建复杂对象。主要的区别是生成器模式着重于一步步构造一个复杂对象。而抽象工厂模式着重于多个系列的产品对象(简单的或是复杂的)。
生成器在最后的一步返回产品,而对于抽象工厂来说,产品是立即返回的。

 


原型模式
定义
原型模式是创建型模式的一种,其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”,这个原型是可定制的。
原型模式多用于创建复杂的或者耗时的实例,因为这种情况下,复制一个已经存在的实例使程序运行更高效;或者创建值相等,只是命名不一样的同类数据。

实现

讲解Java设计模式编程中的建造者模式与原型模式

1. client - 创建一个新的对象,然后通过clone得到另外一个对象。
2. prototype - 定义一个clone自己的抽象方法。
3. concreteprototype - 实现clone方法。

public interface prototype { 
  public abstract object clone ( ); 
} 
 
  
 
public class concreteprototype implements prototype { 
  public object clone() { 
    return super.clone(); 
  } 
} 
 
public class client { 
 
  public static void main( string arg[] )  
  { 
    concreteprototype obj1= new concreteprototype (); 
    concreteprototype obj2 = concreteprototype)obj1.clone(); 
  } 
 
} 

实例
1. 游戏中很多元素都是重复的,我们可以使用原型模式复制相同的元素。
2. 制作数据图表时,第一次我们需要从数据库读取数据保存到对象中,当需要制作相同数据的其他图表时,使用原型模式可以避免重新读取数据库。

相关问题和实现
1. 如果需要创建的原型数目不固定,可以创建一个原型管理器,在复制原型对象之前,客户端先在原型管理器中查看
是否存在满足条件的原型对象,如果有,则直接使用,如果没有,克隆一个,这种称作登记形式的原型模式。
2. 复制有两种:深复制和浅复制。浅复制时,复制对象和原型对象共享对象所有的内部变量,两个对象具有一样的内存空间和生命周期。对原型对象的修改同时也修改了它的复制品,反之亦然。

java中只要实现cloneable接口就可以调用object类的clone方法实现浅复制:

public class shallowclone implements cloneable { 
  int age; 
  person person; 
   
  public void setage(int age){ 
    this.age = age; 
  } 
   
  public void setperson(string name){ 
    person = new person(name); 
  } 
   
  public object clone() throws clonenotsupportedexception{ 
    // 默认java实现的是浅复制 
    return super.clone(); 
  } 
} 
 
public class person { 
  string name; 
  public person(string name){ 
    this.name = name; 
  } 
} 
 
public class test { 
  public static void main(string[] args) throws clonenotsupportedexception { 
    shallowclone oldshallowclone = new shallowclone(); 
    oldshallowclone.setage(20); 
    oldshallowclone.setperson("eric"); 
    system.out.println("oldname: " + oldshallowclone.person.name + " age: " + oldshallowclone.age); 
     
    shallowclone newshallowclone = (shallowclone)oldshallowclone.clone(); 
    system.out.println("newname: " + newshallowclone.person.name + " age: " + newshallowclone.age); 
     
    oldshallowclone.age = 30; 
    oldshallowclone.person.name = "frank"; 
    system.out.println("newname: " + newshallowclone.person.name + " age: " + newshallowclone.age); 
  } 
} 

输出:

oldname: eric age: 20
newname: eric age: 20
newname: frank age: 20

可见浅复制复制的是对象的引用,当改变对象的值时,复制后的对象也会改变,而java的基本类型是复制的值。

下面我们实现深复制:

public class deepclone { 
  int age; 
  person person; 
   
  public void setage(int age){ 
    this.age = age; 
  } 
   
  public void setperson(string name){ 
    person = new person(name); 
  } 
   
  public deepclone(deepclone deepclone){ 
    this.age = deepclone.age; 
    this.person = new person(deepclone.person.name); 
  } 
   
  public deepclone() {} 
 
  public object clone() throws clonenotsupportedexception{ 
    return new deepclone(this); 
  } 
} 
 
public class test { 
  public static void main(string[] args) throws clonenotsupportedexception { 
    deepclone olddeepclone = new deepclone(); 
    olddeepclone.setage(20); 
    olddeepclone.setperson("eric"); 
    system.out.println("oldname: " + olddeepclone.person.name + " age: " + olddeepclone.age); 
     
    deepclone newdeepclone = (deepclone)olddeepclone.clone(); 
    system.out.println("newname: " + newdeepclone.person.name + " age: " + newdeepclone.age); 
     
    olddeepclone.age = 30; 
    olddeepclone.person.name = "frank"; 
    system.out.println("newname: " + newdeepclone.person.name + " age: " + newdeepclone.age); 
  } 
} 

输出:

oldname: eric age: 20
newname: eric age: 20
newname: eric age: 20

上面的复制方法中,我们重新创建了一个对象,并且重新创建了引用,实现了深度复制。

优点
1. 复制比new性能更好。
2. 简化或者隐藏创建对象的细节,直接复制。