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

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

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

实现

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

时间: 2016-01-31

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

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

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

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

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

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

Java设计模式之迭代器模式_动力节点Java学院整理

定义:提供一种方法访问一个容器对象中各个元素,而又不暴露该对象的内部细节. 类型:行为类模式 类图: 如果要问Java中使用最多的一种模式,答案不是单例模式,也不是工厂模式,更不是策略模式,而是迭代器模式,先来看一段代码吧: public static void print(Collection coll){ Iterator it = coll.iterator(); while(it.hasNext()){ String str = (String)it.next(); System.out

Java设计模式之解释器模式_动力节点Java学院整理

定义:给定一种语言,定义他的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中句子. 类型:行为类模式 类图: 解释器模式是一个比较少用的模式,本人之前也没有用过这个模式.下面我们就来一起看一下解释器模式. 解释器模式的结构 抽象解释器:声明一个所有具体表达式都要实现的抽象接口(或者抽象类),接口中主要是一个interpret()方法,称为解释操作.具体解释任务由它的各个实现类来完成,具体的解释器分别由终结符解释器TerminalExpression和非终结符解释器Nonterm

Java设计模式之策略模式_动力节点Java学院整理

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

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

引言 Java 动态代理机制的出现,使得 Java 开发人员不用手工编写代理类,只要简单地指定一组接口及委托类对象,便能动态地获得代理类.代理类会负责将所有的方法调用分派到委托对象上反射执行,在分派执行的过程中,开发人员还可以按需调整委托类对象及其功能,这是一套非常灵活有弹性的代理框架.通过阅读本文,读者将会对 Java 动态代理机制有更加深入的理解.本文首先从 Java 动态代理的运行机制和特点出发,对其代码进行了分析,推演了动态生成类的内部实现. 代理:设计模式 代理是一种常用的设计模式,其

Java设计模式之命令模式_动力节点Java学院整理

定义:将一个请求封装成一个对象,从而让你使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能. 类型:行为类模式 类图: 命令模式的结构 顾名思义,命令模式就是对命令的封装,首先来看一下命令模式类图中的基本结构: Command类:是一个抽象类,类中对需要执行的命令进行声明,一般来说要对外公布一个execute方法用来执行命令. ConcreteCommand类:Command类的实现类,对抽象类中声明的方法进行实现. Client类:最终的客户端调用类.

Java设计模式之备忘录模式_动力节点Java学院

定义:在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态.这样就可以将该对象恢复到原先保存的状态 类型:行为类 类图: 我们在编程的时候,经常需要保存对象的中间状态,当需要的时候,可以恢复到这个状态.比如,我们使用Eclipse进行编程时,假如编写失误(例如不小心误删除了几行代码),我们希望返回删除前的状态,便可以使用Ctrl+Z来进行返回.这时我们便可以使用备忘录模式来实现. 备忘录模式的结构 发起人:记录当前时刻的内部状态,负责定义哪些属于备份范围的状态,负责创建和

Java创建类模式_动力节点Java学院整理

创建类模式主要关注对象的创建过程,将对象的创建过程进行封装,使客户端可以直接得到对象,而不用去关心如何创建对象.创建类模式有5种,分别是: 单例模式:用于得到内存中的唯一对象. 工厂方法模式:用于创建复杂对象. 抽象工厂模式:用于创建一组相关或相互依赖的复杂对象. 建造者模式:用于创建模块化的更加复杂的对象. 原型模式:用于得到一个对象的拷贝. 为什么需要创建性模式 首先,在编程中,对象的创建通常是一件比较复杂的事,因为,为了达到降低耦合的目的,我们通常采用面向抽象编程的方式,对象间的

设计模式之模版方法模式_动力节点Java学院整理

定义:定义一个操作中算法的框架,而将一些步骤延迟到子类中,使得子类可以不改变算法的结构即可重定义该算法中的某些特定步骤. 类型:行为类模式 类图: 事实上,模版方法是编程中一个经常用到的模式.先来看一个例子,某日,程序员A拿到一个任务:给定一个整数数组,把数组中的数由小到大排序,然后把排序之后的结果打印出来.经过分析之后,这个任务大体上可分为两部分,排序和打印,打印功能好实现,排序就有点麻烦了.但是A有办法,先把打印功能完成,排序功能另找人做. abstract class AbstractS

设计模式之责任链模式_动力节点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