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

时间:2021-10-23 05:07:30

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

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

实现

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

 

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/** "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方法。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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方法实现浅复制:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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);
  }
}

输出:

?
1
2
3
oldname: eric age: 20
newname: eric age: 20
newname: frank age: 20

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

下面我们实现深复制:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
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);
  }
}

输出:

?
1
2
3
oldname: eric age: 20
newname: eric age: 20
newname: eric age: 20

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

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