Prototype

依赖关系的倒置
抽象不应该依赖于实现细节，实现细节应该依赖于抽象。抽象变化慢，实现变化快。
动机：
在软件系统中，经常面临着某些结构复杂的对象的创建工作由于需求的变化，这些对象经常面临着剧烈的

变化，但是他们却拥有比较稳定一致的接口。
如何应对这种变化？如何向客户程序隔离出这些易变对象，从而使得依赖这些易变对象的客户程序不随着

需求改变而改变？
意图：
使用原型实例指定创建对象的种类，然后通过拷贝这些原型来创建新的对象。
模式要点：
prototype模式同样用于隔离类对象的使用者和具体类型之间的耦合关系，它同样要求这些易变类拥有稳

定的接口。
prototype模式对于如何创建易变类的实体对象采用原型克隆的方法来做，它使得我们可以非常灵活地动

态创建拥有某些稳定接口的新对象所需工作仅仅是注册一个新类的对象，然后在任何需要的地方不断的

Clone.
prototype模式中的clone方法最好实现深拷贝。

有关创建性模式的讨论
singleton模式解决的是实体对象个数的问题。除了singleton外，其他创建型模式解决的都是new所带来

的耦合关系。
Factory method,abstract factory,builder都需要一个额外的工厂类来负责实例化易变对象，而

prototype则是通过原型（一个特殊的工厂类）来克隆易变对象。
如果遇到易变类，起初的设计通常从Factory method开始，当遇到更多的复杂变化时，再考虑重构为其他

三种工厂模式(abstract factory, builder, prototype)。

code:

/**
 * @(#)Prototype pattern
 *
 *
 * @author leo
 * @version 1.00 2008/3/7
 */

//GameSystem好比高层抽象，它依赖具体实现，这样不好。
class GameSystem {
    public void run() {
     NormalActor normalActor1 = new NormalActor();
     NormalActor normalActor2 = new NormalActor();
     NormalActor normalActor3 = new NormalActor();
     NormalActor normalActor4 = new NormalActor();
     NormalActor normalActor5 = new NormalActor();
     
     FlyActor flyActor1 = new FlyActor();
     FlyActor flyActor2 = new FlyActor();
     
     WaterActor waterActor1 = new WaterActor();
     WaterActor waterActor2 = new WaterActor();
    }
}

//改进
//NormalActor,FlyActor,WaterActor为抽象

//NormalActorA,NormalActorB
//FlyActorA,FlyActorB
//WaterActorA,WaterActorB都是实现类型
abstract class NormalActor {
 public abstract NormalActor clone();
}

abstract class FlyActor {
 public abstract FlyActor clone();
}

abstract class WaterActor {
 public abstract WaterActor clone();
}

class NormalActorA extends NormalActor {
 public NormalActor clone() {
  return new NormalActorA();
 }
}

class NormalActorB extends NormalActor {
 public NormalActor clone() {
  return new NormalActorB();
 }
}

class FlyActorA extends FlyActor {
 public FlyActor clone() {
  return new FlyActorA();
 }
}

class FlyActorB extends FlyActor {
 public FlyActor clone() {
  return new FlyActorB();
 }
}

class WaterActorA extends WaterActor {
 public WaterActor clone() {
  return new WaterActorA();
 }
}

class WaterActorB extends WaterActor {
 public WaterActor clone() {
  return new WaterActorB();
 }
}

class GameSystem {
    public void run(NormalActor normalActor, FlyActor flyActor, WaterActor waterActor) {
     NormalActor normalActor1 = normalActor.clone();
     NormalActor normalActor2 = normalActor.clone();
     NormalActor normalActor3 = normalActor.clone();
     NormalActor normalActor4 = normalActor.clone();
     NormalActor normalActor5 = normalActor.clone();
     
     FlyActor flyActor1 = flyActor.clone();
     FlyActor flyActor2 = flyActor.clone();
     
     WaterActor waterActor1 = waterActor.clone();
     WaterActor waterActor2 = waterActor.clone();
    }
}

//以后系统变化可能修改的就是传入得实际参数，例如新的类型NormalActorC
//如果直接调用clone方法请注意对象传递的处理，如果一般类型则没有问题，所以需要重写clone方法。
class App {
 public static void main (String[] args) {
  GameSystem gameSystem = new GameSystem();
  
  gameSystem.run(new NormalActorA(), new FlyActorB(), new WaterActorA();
 }
}