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

相关模式

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

生成器在最后的一步返回产品，而对于抽象工厂来说，产品是立即返回的。

原型模式定义

原型模式是创建型模式的一种,其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”，这个原型是可定制的。

原型模式多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；或者创建值相等，只是命名不一样的同类数据。

实现

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