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