java prototype原型模型模式讲解

最新推荐文章于 2024-07-16 07:00:00 发布

weixin_34279061

最新推荐文章于 2024-07-16 07:00:00 发布

阅读量116

点赞数

文章标签： java 数据库设计模式

原文链接：http://blog.51cto.com/77857/147181

版权

一、介绍

原型模式是在已指定对象的基础上，然后通过拷贝这些原型对象创建新的对象。

名称
Prototype（原型模式）

意图
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

适用

环境
当一个系统应该独立于它的产品创建、构成和表示时，要使用Prototype模式；以及：

当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者为了避免创建一个与产品类层次平行的工厂类层次时；或者当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们

可能比每次用合适的状态手工实例化该类更方便一些。

二、实例（克隆的层次性）

实例的UML图如下：

提供一个基本的原型工厂类，定义make方法和传入参数定义：

Java代码

public class PrototypeFactory {
AbstractSpoon prototypeSpoon;
AbstractFork prototypeFork;
public PrototypeFactory(AbstractSpoon spoon, AbstractFork fork) {
prototypeSpoon = spoon;
prototypeFork = fork;
}
public AbstractSpoon makeSpoon() {
return (AbstractSpoon)prototypeSpoon.clone();
}
public AbstractFork makeFork() {
return (AbstractFork)prototypeFork.clone();
}
}

public class PrototypeFactory {      
    AbstractSpoon prototypeSpoon;    
    AbstractFork prototypeFork;    
        
    public PrototypeFactory(AbstractSpoon spoon, AbstractFork fork) {    
       prototypeSpoon = spoon;    
       prototypeFork = fork;    
   }    
        
   public AbstractSpoon makeSpoon() {    
       return (AbstractSpoon)prototypeSpoon.clone();    
   }    
   public AbstractFork makeFork() {    
       return (AbstractFork)prototypeFork.clone();    
   }    
}

定义原型抽象接口AbstractSpoon和原型实际类SoupSpoon，AbstractSpoon类实现了Colneable接口，并重载了clone()方法：

Java代码

public abstract class AbstractSpoon implements Cloneable {
String spoonName;
public void setSpoonName(String spoonName) {
this.spoonName = spoonName;
}
public String getSpoonName() {
return this.spoonName;
}
public Object clone() {
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
System.err.println("AbstractSpoon is not Cloneable");
}
return object;
}
}
public class SoupSpoon extends AbstractSpoon {
public SoupSpoon() {
setSpoonName("Soup Spoon");
}
}

public abstract class AbstractSpoon implements Cloneable {      
   String spoonName;     
        
   public void setSpoonName(String spoonName) {    
       this.spoonName = spoonName;    
   }    
   public String getSpoonName() {    
       return this.spoonName;    
   }    
       
   public Object clone() {    
       Object object = null;    
       try {    
           object = super.clone();    
       } catch (CloneNotSupportedException exception) {    
           System.err.println("AbstractSpoon is not Cloneable");    
       }    
       return object;    
   }    
}    
   
public class SoupSpoon extends AbstractSpoon {      
   public SoupSpoon() {    
       setSpoonName("Soup Spoon");    
   }    
}

同样，我们也定义了另外一个Fork方面的原型接口及实际类：

Java代码

public abstract class AbstractFork implements Cloneable
{
String forkName;
public void setForkName(String forkName) {
this.forkName = forkName;
}
public String getForkName() {
return this.forkName;
}
public Object clone()
{
Object object = null;
try {
object = super.clone();
} catch (CloneNotSupportedException exception) {
System.err.println("AbstractFork is not Cloneable");
}
return object;
}
}
public class SaladFork extends AbstractFork {
public SaladFork() {
setForkName("Salad Fork");
}
}

public abstract class AbstractFork implements Cloneable    
{      
   String forkName;     
        
   public void setForkName(String forkName) {    
       this.forkName = forkName;    
   }    
   public String getForkName() {    
       return this.forkName;    
   }    
       
   public Object clone()     
   {    
       Object object = null;    
       try {    
           object = super.clone();    
       } catch (CloneNotSupportedException exception) {    
           System.err.println("AbstractFork is not Cloneable");    
       }    
       return object;    
   }       
}    
   
public class SaladFork extends AbstractFork {      
   public SaladFork() {    
       setForkName("Salad Fork");    
   }    
}

看看，在实际工作中，我们如何运用原型模式吧！

Java代码

class TestPrototype {
public static void main(String[] args) {
System.out.println(
"Creating a Prototype Factory with " +
" a SoupSpoon and a SaladFork");
PrototypeFactory prototypeFactory =
new PrototypeFactory(new SoupSpoon(), new SaladFork());
AbstractSpoon spoon =
prototypeFactory.makeSpoon();
AbstractFork fork =
prototypeFactory.makeFork();
System.out.println("Getting the Spoon and Fork name:");
System.out.println("Spoon: " + spoon.getSpoonName() +
", Fork: " + fork.getForkName());
System.out.println(" ");
System.out.println("Creating a Prototype Factory " +
"with a SaladSpoon and a SaladFork");
prototypeFactory =
new PrototypeFactory(new SaladSpoon(), new SaladFork());
spoon = prototypeFactory.makeSpoon();
fork = prototypeFactory.makeFork();
System.out.println("Getting the Spoon and Fork name:");
System.out.println("Spoon: " + spoon.getSpoonName() +
", Fork: " + fork.getForkName());
}
}

class TestPrototype {     
   public static void main(String[] args) {    
       System.out.println(    
         "Creating a Prototype Factory with " +     
         " a SoupSpoon and a SaladFork");    
       PrototypeFactory prototypeFactory =     
         new PrototypeFactory(new SoupSpoon(), new SaladFork());    
       AbstractSpoon spoon =     
         prototypeFactory.makeSpoon();    
       AbstractFork fork =     
         prototypeFactory.makeFork();    
       System.out.println("Getting the Spoon and Fork name:");    
       System.out.println("Spoon: " + spoon.getSpoonName() +     
                          ", Fork: " + fork.getForkName());    
       System.out.println(" ");           
       System.out.println("Creating a Prototype Factory " +     
                          "with a SaladSpoon and a SaladFork");    
       prototypeFactory =     
         new PrototypeFactory(new SaladSpoon(), new SaladFork());    
       spoon = prototypeFactory.makeSpoon();    
       fork = prototypeFactory.makeFork();    
       System.out.println("Getting the Spoon and Fork name:");    
       System.out.println("Spoon: " + spoon.getSpoonName() +     
                          ", Fork: " + fork.getForkName());    
    }    
}

三、分析

从例子中，我们可以针对原型模式，统计出的以下这些角色：

AbstractPrototype 原型接口或抽象类，实现了Cloneable接口，为工厂提供通用的原型接口声明。在该接口类中，重载实现了Cloneable接口的clone()方法。
ConcretePrototype 原型实体对象定义类，可以由一个或多个，它也是加工工厂的实际原材料。
PrototypeFactory 原型的加工工厂，用来定义原型对象的指定，以及拷贝复制的过程。

实现一个原型模式，需要以下几个关键步骤：
1、定义最基本的原型接口或抽象类AbstractPrototype，这里可以定义一种或多种不同的原型。
2、实现或继承已有的原型接口，定义实体原型对象类AbstractPrototype.
3、创建一个Client性质的类，如通用的PrototypeFactory ，通过原型模式来加工生产实际产品对象。

一句话总结原型模式的特点，即：请求一个原型来克隆对象自身。

通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。

当然，原型模式也有它的缺点。每一个原型的子类都必须实现Clone操作，这可能会很困难。例如，当所考虑的类已经存在时就难以新增Clone操作。当内部包括一些不支持拷贝或由循环引用的对象时，实现克隆可能也会很困难的。

(二)克隆的深浅性

prototype原型模式，简单明了的讲是，克隆并复用原型对象模式。
当客户机需要创建对象集时，其中对象是相似的，或仅在状态方面有所不同，并且创建此类对象将花费很多的时间，所涉及的处理也较多。比如，通过复制具有类似结构代码，并进行修改，来创建一个新的实例，这时可以考虑采用原型模式，这样就不必通过复制修改代码来实现新的实例，只要克隆一下另一个实例，通过修改相应的属性的值来到达你的目的。
克隆有浅克隆和深克隆。

Java代码