博客
关于我
强烈建议你试试无所不能的chatGPT，快点击我
java prototype原型模型模式讲解
阅读量：4220 次
发布时间：2019-05-26

本文共 7365 字，大约阅读时间需要 24 分钟。

一、介绍
原型模式是在已指定对象的基础上，然后通过拷贝这些原型对象创建新的对象。
名  称
Prototype（原型模式）
意  图
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
适  用
环  境
当一个系统应该独立于它的产品创建、构成和表示时，要使用Prototype模式；以及：
当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者为了避免创建一个与产品类层次平行的工厂类层次时；或者 当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们
可能比每次用合适的状态手工实例化该类更方便一些。
 
二、实例（克隆的层次性）
实例的UML图如下：
 
提供一个基本的原型工厂类，定义make方法和传入参数定义：
Java代码
  1. public class PrototypeFactory {         
  2.     AbstractSpoon prototypeSpoon;       
  3.     AbstractFork prototypeFork;       
  4.            
  5.     public PrototypeFactory(AbstractSpoon spoon, AbstractFork fork) {       
  6.        prototypeSpoon = spoon;       
  7.        prototypeFork = fork;       
  8.    }       
  9.            
  10.    public AbstractSpoon makeSpoon() {       
  11.        return (AbstractSpoon)prototypeSpoon.clone();       
  12.    }       
  13.    public AbstractFork makeFork() {       
  14.        return (AbstractFork)prototypeFork.clone();       
  15.    }       
  16. }    
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代码
  1. public abstract class AbstractSpoon implements Cloneable {         
  2.    String spoonName;        
  3.            
  4.    public void setSpoonName(String spoonName) {       
  5.        this.spoonName = spoonName;       
  6.    }       
  7.    public String getSpoonName() {       
  8.        return this.spoonName;       
  9.    }       
  10.           
  11.    public Object clone() {       
  12.        Object object = null;       
  13.        try {       
  14.            object = super.clone();       
  15.        } catch (CloneNotSupportedException exception) {       
  16.            System.err.println("AbstractSpoon is not Cloneable");       
  17.        }       
  18.        return object;       
  19.    }       
  20. }       
  21.       
  22. public class SoupSpoon extends AbstractSpoon {         
  23.    public SoupSpoon() {       
  24.        setSpoonName("Soup Spoon");       
  25.    }       
  26. }   
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代码
  1. public abstract class AbstractFork implements Cloneable       
  2. {         
  3.    String forkName;        
  4.            
  5.    public void setForkName(String forkName) {       
  6.        this.forkName = forkName;       
  7.    }       
  8.    public String getForkName() {       
  9.        return this.forkName;       
  10.    }       
  11.           
  12.    public Object clone()        
  13.    {       
  14.        Object object = null;       
  15.        try {       
  16.            object = super.clone();       
  17.        } catch (CloneNotSupportedException exception) {       
  18.            System.err.println("AbstractFork is not Cloneable");       
  19.        }       
  20.        return object;       
  21.    }          
  22. }       
  23.       
  24. public class SaladFork extends AbstractFork {         
  25.    public SaladFork() {       
  26.        setForkName("Salad Fork");       
  27.    }       
  28. }  
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代码
  1. class TestPrototype {        
  2.    public static void main(String[] args) {       
  3.        System.out.println(       
  4.          "Creating a Prototype Factory with " +        
  5.          " a SoupSpoon and a SaladFork");       
  6.        PrototypeFactory prototypeFactory =        
  7.          new PrototypeFactory(new SoupSpoon(), new SaladFork());       
  8.        AbstractSpoon spoon =        
  9.          prototypeFactory.makeSpoon();       
  10.        AbstractFork fork =        
  11.          prototypeFactory.makeFork();       
  12.        System.out.println("Getting the Spoon and Fork name:");       
  13.        System.out.println("Spoon: " + spoon.getSpoonName() +        
  14.                           ", Fork: " + fork.getForkName());       
  15.        System.out.println(" ");              
  16.        System.out.println("Creating a Prototype Factory " +        
  17.                           "with a SaladSpoon and a SaladFork");       
  18.        prototypeFactory =        
  19.          new PrototypeFactory(new SaladSpoon(), new SaladFork());       
  20.        spoon = prototypeFactory.makeSpoon();       
  21.        fork = prototypeFactory.makeFork();       
  22.        System.out.println("Getting the Spoon and Fork name:");       
  23.        System.out.println("Spoon: " + spoon.getSpoonName() +        
  24.                           ", Fork: " + fork.getForkName());       
  25.     }       
  26. }    
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代码
  1. class Person implements Cloneable {   
  2.   private String name;   
  3.   public String getName() {   
  4.     return name;   
  5.   }   
  6.   public void setName(String s) {   
  7.     name = s;   
  8.   }   
  9.   public Person(String s) {   
  10.     name = s;   
  11.   }   
  12.   public Object clone() {   
  13.     Person p = new Person(name);//深克隆   
  14.     return p;   
  15.     /*try {//浅克隆  
  16.       return super.clone();  
  17.     } catch (CloneNotSupportedException e) {  
  18.       return null;  
  19.     }*/  
  20.   }   
  21. }   
  22. public class CopyTest {   
  23.   public static void main(String[] args) {   
  24.     Person p = new Person("A");   
  25.     System.out.println(p.getName());   
  26.     Person q = (Person) p.clone();   
  27.     System.out.println(q.getName());   
  28.     q.setName("B");   
  29.     System.out.println(q.getName());   
  30.     System.out.println(p.getName());   
  31.   }   
  32. } 

转载地址：http://ynlmi.baihongyu.com/

你可能感兴趣的文章
UVM：8.2.2 重载的方式及种类
查看>>
UVM：8.2.3 复杂的重载
查看>>
UVM：8.2.4 factory 机制的调试
查看>>
UVM：8.3.1 重载transaction
查看>>
UVM：8.3.2 重载sequence
查看>>
leetcode171.[math] Excel Sheet Column Number
查看>>
Log4j配置
查看>>
java发送https请求
查看>>
java发送https请求证书问题
查看>>
js新消息提醒
查看>>
js窗体消息提醒
查看>>
深入Hibernate映射文件（二）——<hibernate-mapping>的属性
查看>>
详解在Spring中进行集成测试
查看>>
Hibernate 的工具类
查看>>
Struts2中过滤器和拦截器的区别
查看>>
51单片机：led灯闪烁10次后熄灭
查看>>
安卓使用okhttp上传文件，服务端PHP接收
查看>>
51单片机：设计有四位数码管，设计3个按键，k1,k2,k3;k1为模式键，第一次按下，显示初始值，k2，k3有效，k2按一次初值加1，k3按一次初值减1；k1第二次按下停止；k1第三次按下清零；
查看>>
安卓：阿里逆地理编码，可直接拿去用
查看>>
thinkphp源码没问题却各种报错，Namespace declaration statement has to be the very first statement in the script
查看>>
喝酒易醉，品茶养心，人生如梦，品茶悟道，何以解忧？唯有杜康！-- 愿君每日到此一游！
当前时间: 2024-09-25 20:36:28   当前IP: 3.145.17.18   联系邮箱:javaeecc@qq.com     Copyright © 2020 - 2022 baihongyu.com 京ICP备2021015314号-2
强烈建议你试试无所不能的CHAT-GPT，快点击我
强烈建议你试试无所不能的CHAT-GPT，快点击我