讲解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 就可以实现。

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

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

实现

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. 简化或者隐藏创建对象的细节,直接复制。

时间: 2016-01-31

Java设计模式之原型模式(Prototype模式)介绍

Prototype模式定义:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象. Prototype模式允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建. 如何使用原型模式 因为Java中的提供clone()方法来实现对象的克隆,所以Prototype模式实现一下子变得很简单.以勺子为例: 复制代码 代码如下: public abstract cl

设计模式之原型模式_动力节点Java学院整理

定义:用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象. 类型:创建类模式 类图: 原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype.Prototype类需要具备以下两个条件: 实现Cloneable接口.在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法.在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedExcepti

详解Java的设计模式编程中的原型模式

定义:用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象. 类型:创建类模式 类图: 原型模式主要用于对象的复制,它的核心是就是类图中的原型类Prototype.Prototype类需要具备以下两个条件: 实现Cloneable接口.在java语言有一个Cloneable接口,它的作用只有一个,就是在运行时通知虚拟机可以安全地在实现了此接口的类上使用clone方法.在java虚拟机中,只有实现了这个接口的类才可以被拷贝,否则在运行时会抛出CloneNotSupportedExcepti

深入解析Java的设计模式编程中的模板方法模式

定义:  定义一个操作中的算法的框架,而将一些步骤延迟到子类中.使得子类可以不改变一个算法的结构即可重新定义该算法的某些特定步骤. 听起来好高端的样子,我的理解: 1.父类声明了若干个抽象方法(基本方法)和若干个具体方法(模板方法) 2.抽象方法是一个算法(过程)的步骤,在子类中实现 3.模板方法是一个算法(过程)的框架,在父类中已经约定好,实现对基本方法调用,完成固定的逻辑 4.一个算法(过程)的结构在父类中定义,具体的实现细节则在子类中实现 注:为了防止恶意操作,一般模板方法都加上final

实例讲解Java的设计模式编程中责任链模式的运用

定义:使多个对象都有机会处理请求,从而避免了请求的发送者和接收者之间的耦合关系.将这些对象连成一条链,并沿着这条链传递该请求,直到有对象处理它为止. 类型:行为类模式 类图: 首先来看一段代码: public void test(int i, Request request){ if(i==1){ Handler1.response(request); }else if(i == 2){ Handler2.response(request); }else if(i == 3){ Handler3

详解C#的设计模式编程之抽象工厂模式的应用

这里首先以一个生活中抽象工厂的例子来实现一个抽象工厂,然后再给出抽象工厂的定义和UML图来帮助大家更好地掌握抽象工厂模式,同时大家在理解的时候,可以对照抽象工厂生活中例子的实现和它的定义来加深抽象工厂的UML图理解.抽象工厂模式比其它工厂模式更加抽象,抽象工厂模式适用与多个抽象类的情况下,通过工厂返回多个抽象类中你需要得到的具体子类实例. 抽象工厂模式比其它工厂模式更加抽象,抽象工厂模式适用与多个抽象类的情况下,通过工厂返回多个抽象类中你需要得到的具体子类实例. 举例阐述抽象工厂模式: 假如中国

详解Java图形化编程中的鼠标事件设计

鼠标事件的事件源往往与容器相关,当鼠标进入容器.离开容器,或者在容器中单击鼠标.拖动鼠标时都会发生鼠标事件.java语言为处理鼠标事件提供两个接口:MouseListener,MouseMotionListener接口. MouseListener接口 MouseListener接口能处理5种鼠标事件:按下鼠标,释放鼠标,点击鼠标.鼠标进入.鼠标退出.相应的方法有: (1) getX():鼠标的X坐标 (2) getY():鼠标的Y坐标 (3) getModifiers():获取鼠标的左键或右键

详解Java设计模式编程中的策略模式

定义:定义一组算法,将每个算法都封装起来,并且使他们之间可以互换. 类型:行为类模式 类图: 策略模式是对算法的封装,把一系列的算法分别封装到对应的类中,并且这些类实现相同的接口,相互之间可以替换.在前面说过的行为类模式中,有一种模式也是关注对算法的封装--模版方法模式,对照类图可以看到,策略模式与模版方法模式的区别仅仅是多了一个单独的封装类Context,它与模版方法模式的区别在于:在模版方法模式中,调用算法的主体在抽象的父类中,而在策略模式中,调用算法的主体则是封装到了封装类Context中

详解C#设计模式编程中的模板方法模式使用

一.引言 提到模板,大家肯定不免想到生活中的"简历模板"."论文模板"."Word中模版文件"等,在现实生活中,模板的概念就是--有一个规定的格式,然后每个人都可以根据自己的需求或情况去更新它,例如简历模板,下载下来的简历模板的格式都是相同的,然而我们下载下来简历模板之后我们可以根据自己的情况填充不同的内容要完成属于自己的简历.在设计模式中,模板方法模式中模板和生活中模板概念非常类似,下面让我们就详细介绍模板方法的定义,大家可以根据生活中模板的概

详解Objective-C设计模式编程中对备忘录模式的运用

基本理解 这个模式有三个关键角色:原发器(Originator).备忘录(Memento).看管人(caretaker).三者的基本关系是:原发器创建一个包含其状态的备忘录,并传给看管人.看管人不知道如何与备忘录交互,但会把备忘录放在一个安全之处保管好. 备忘录(Memento):在 不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样以后就可以将该对象回复到原先保存的状态. Originator(发起人):负责创建一个备忘录,用以记录当前时刻它的内部状态,并且可使用恢

详解C++设计模式编程中对访问者模式的运用

访问者模式(visitor),表示一个作用于某对象结构中的各元素的操作.它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作.访问者模式适用于数据结构相对稳定的系统.它把数据结构和作用于结构上的操作之间的耦合解脱开,使得操作集合可以相对自由地演化.访问者模式的目的是要把处理从数据结构分离出来.很多系统可以按照算法和数据结构分开,如果这样的系统有比较稳定的数据结构,又有易于变化的算法的话,使用访问者模式就是比较合适的,因为访问者模式使得算法操作的增加变得容易.反之,如果这样的系统的数据结

详解Java如何改变字符串中的字符

今天做某度的笔试题遇到一个编程题需要用到字符串中的字符的即时改变.题中给出的一个String字符串.绞尽脑汁试图使用构建一个新的String的方式来做,而后发觉十分麻烦. 做题的时候只觉得StringBuilder/StringBuffer(由于这两个类的方法基本完全相同,下面只说其中一个,另一个也一样)中会有操作某字符的方法,想了半天没什么印象,所以这个题应该是直接挂了. 做完之后查了一下API.果然发现一个方法,如下图所示: cStringBuilder.setCharAt() 可以实现很方