Prototype设计模式

最新推荐文章于 2024-09-19 14:48:48 发布
最新推荐文章于 2024-09-19 14:48:48 发布
阅读量792 收藏 2
点赞数
分类专栏： java 文章标签： prototype 浅拷贝 深拷贝

原型模式是一种创建型设计模式,它通过复制一个已经存在的实例来返回新的实例,而不是新建实例.被复制的实例就是我们所称的原型,这个原型是可定制的.
原型模式多用于创建复杂的或者耗时的实例, 因为这种情况下,复制一个已经存在的实例可以使程序运行更高效,或者创建值相等,只是命名不一样的同类数据.

原型模式中的拷贝分为"浅拷贝"和"深拷贝":
浅拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象.
深拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制.

由于使用clone()方法来拷贝一个对象是从内存二进制流中进行IO读写，所以拷贝得到一个对象是不会执行该对象所对应类的构造函数的。总结如下：

1、 构造函数不会被执行；
2、 类的成员变量中若有引用类型的变量（数组也是一种对象），默认的clone()并不会对其进行拷贝，需自行提供深拷贝；
String类型与int、long、char等基本类型类似，默认地会被拷贝。
总之，Java中原型模式clone()方法对我们隐藏了许多细节，或者说必要操作，它的实现机制涉及到了反射、IO流操作、序列化等，只有弄清楚这一系列的知识才能更深入地理解这些相关的知识点。

类图:

实例一:浅拷贝
public class Prototype implements Cloneable {
 private String name;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public Object clone() {
  try {
   return super.clone();
  } catch (CloneNotSupportedException e) {   
   e.printStackTrace();
   return null;
  }
 } 
 
}

public class TestMain {

 public static void main(String[] args) {
  testPrototype();
 }
 
 private static void testPrototype(){
  Prototype pro = new Prototype();
  pro.setName("original object");
  Prototype pro1 = (Prototype)pro.clone();
  pro.setName("changed object1");
  
  System.out.println("original object:" + pro.getName());
  System.out.println("cloned object:" + pro1.getName());
  
 }

}
结果:
original object:changed object1
cloned object:original object


实例二: 浅拷贝
public class Prototype{
 private String name;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 } 
 
}
public class NewPrototype implements Cloneable {
 
 private String id;
 
 public String getId() {
  return id;
 }

 public void setId(String id) {
  this.id = id;
 }

 private Prototype prototype;
 
 public Prototype getPrototype() {
  return prototype;
 }

 public void setPrototype(Prototype prototype) {
  this.prototype = prototype;
 }


 public Object clone(){ 
  try {
   return super.clone();
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
   return null;
  }  
 }

}
public class TestMain {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  testPrototype();
 }
 
 private static void testPrototype(){
  Prototype pro = new Prototype();
  pro.setName("original object");
  NewPrototype newObj = new NewPrototype();
  newObj.setId("test1");
  newObj.setPrototype(pro);
  
  NewPrototype copyObj = (NewPrototype)newObj.clone();
  copyObj.setId("testCopy");
  copyObj.getPrototype().setName("changed object");
  
  System.out.println("original object id:" + newObj.getId());
  System.out.println("original object name:" + newObj.getPrototype().getName());
  
  System.out.println("cloned object id:" + copyObj.getId());
  System.out.println("cloned object name:" + copyObj.getPrototype().getName());
  
 }

}

结果:
original object id:test1
original object name:changed object
cloned object id:testCopy
cloned object name:changed object


实例三: 深拷贝
public class Prototype implements Cloneable {
 private String name;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public Object clone() {
  try { 
   return super.clone();
  } catch (CloneNotSupportedException e) {   
   e.printStackTrace();
   return null;
  }
 } 
 
}

public class NewPrototype implements Cloneable {
 
 private String id;
 
 public String getId() {
  return id;
 }

 public void setId(String id) {
  this.id = id;
 }

 private Prototype prototype;
 
 public Prototype getPrototype() {
  return prototype;
 }

 public void setPrototype(Prototype prototype) {
  this.prototype = prototype;
 }


 public Object clone(){
  NewPrototype ret = null;
  try {
   ret = (NewPrototype)super.clone();
   ret.prototype = (Prototype)this.prototype.clone();
   return ret;
  } catch (CloneNotSupportedException e) {
   e.printStackTrace();
   return null;
  }  
 }

}

public class TestMain {

 /**
  * @param args
  */
 public static void main(String[] args) {
  testDeepCopy();
 }
 
 private static void testDeepCopy(){
  Prototype pro = new Prototype();
  pro.setName("original object");
  NewPrototype newObj = new NewPrototype();
  newObj.setId("test1");
  newObj.setPrototype(pro);
  
  NewPrototype copyObj = (NewPrototype)newObj.clone();
  copyObj.setId("testCopy");
  copyObj.getPrototype().setName("changed object");
  
  System.out.println("original object id:" + newObj.getId());
  System.out.println("original object name:" + newObj.getPrototype().getName());
  
  System.out.println("cloned object id:" + copyObj.getId());
  System.out.println("cloned object name:" + copyObj.getPrototype().getName());
  
 }

}

结果:
original object id:test1
original object name:original object
cloned object id:testCopy
cloned object name:changed object

实例四: 利用串行化来做深复制
把对象写道流里的过程是串行化(Serilization)过程;把对象从流中读出来是并行化(Deserialization)过程. 写在流里的是对象的一个拷贝,然后再从流里读出来重建对象.
public class PrototypeSe implements Serializable {

 private String name;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

}

public class NewPrototypeSe implements Serializable {
 
 private String id;
 
 public String getId() {
  return id;
 }

 public void setId(String id) {
  this.id = id;
 }

 private PrototypeSe prototype;
 
 public PrototypeSe getPrototype() {
  return prototype;
 }

 public void setPrototype(PrototypeSe prototype) {
  this.prototype = prototype;
 }
 
 public Object deepClone(){
  try {
   ByteArrayOutputStream bo = new ByteArrayOutputStream();
   ObjectOutputStream oo = new ObjectOutputStream(bo);   
   oo.writeObject(this);   
   
   ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
   ObjectInputStream oi = new ObjectInputStream(bi);
   return oi.readObject(); 
  } catch (IOException | ClassNotFoundException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   return null;
  }
 }

}

public class TestDeepClone {

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  PrototypeSe po = new PrototypeSe();
  po.setName("test1");
  NewPrototypeSe se = new NewPrototypeSe();
  se.setPrototype(po);
  
  NewPrototypeSe deepClone = (NewPrototypeSe)se.deepClone();
  deepClone.getPrototype().setName("test2");
  
  System.out.println("original name:" + se.getPrototype().getName());
  System.out.println("cloned name:" + deepClone.getPrototype().getName());

 }
}
结果:
original name:test1
cloned name:test2

Watson4Lin
关注
专栏目录
设计模式 —— Prototype 模式
一步一步往上爬
05-31 1204
设计模式之原型模式介绍。原型模式示例、场景分析。
Java设计模式—原型模式（Prototype）
super_song的博客
07-07 775
原型模式 需求：克隆羊 传统解决思路 初始羊 @Data @AllArgsConstructor @NoArgsConstructor public class Sheep { private String name; private int age; private String color; } 克隆 public class Client { public static void main(String[] args) { // 传统解决方法
设计模式之Prototype（原型）
04-01
NULL 博文链接：https://wy649898543.iteye.com/blog/1431591
设计模式：Prototype模式
superbeck的专栏
09-17 2244
在软件开发中，有时候可能会需要创建一些特别复杂的对象，如果系统中已经存在同样类型的对象，并且不同的属性个数相差不大的话，用Prototype模式可能是一个理想的选择。 定义:用原型实例指定创建物件的种类,并且通过拷贝这些原型创建新的物件。  Prototype 模式允许一个物件再创建另外一个可定制的物件,根本无需知道任何如何创建的细节,工作原理是:通过将一个原型物件传给那个要发
设计模式——Prototype模式
最新发布
m0_56391095的博客
09-19 789
学习侯捷C++面向对象高级编程中Prototype模式。
设计模式--Prototype
ReDisaster的博客
08-24 369
原型模式 原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。 这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，...
设计模式 - Prototype
weixin_36213061的博客
05-30 286
Prototype 模式： 当对象种类繁多的时候，我们可以把它们合并到一个类中去。 难以根据类生成实例的时候。 想解耦框架和生成的实例时，使生成框架不依赖于任何类。 当一个实例进行了很多操作，比如关于字段的存入，一些方法对于类内字段的处理时，如果我们想要对实例进行复用，我们就可以考虑使用这种模式，我们不仅将实例复制了，省去了很多操作，而且实例之间虽然字段相同，但是已经是两个实例，操作互不影响,也...
解析设计模式中的Prototype原型模式及在C++中的使用
12-31
原型模式的意图是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。 适用性  当要实例化的类是在运行时刻指定时，例如，通过动态装载；或者 为了避免创建一个与产品类层次平行的工厂类层次时；...
Java设计模式之Prototype原型模式
08-27
Java设计模式之Prototype原型模式 Prototype原型模式是Java设计模式中的一种创建型模式，它主要用于对象的克隆和创建。该模式的主要思想是将一个对象作为原型，然后通过克隆该对象来创建新的对象，从而实现对象的...
设计模式 t05Prototype
06-11
"设计模式 t05Prototype" 标题暗示我们将讨论的是原型（Prototype）设计模式，它是创建型设计模式的一种，主要用在对象复制或克隆的场景。 原型模式的核心思想是通过复制一个已经存在的对象来创建新对象，而不是...
设计模式—原型模式(Prototype)
一起加油吧~
08-28 2517
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需知道任何创建的细节简单说就是先创建一个原型类实例，然后通过克隆的方法来复制一个一样的新对象，这个对象和原来的对象相同或相似核心：通过自带的Clone（）方法和ICloneable接口创建跟该对象相同的新对象，不需要知道具体的创建细节。就是具有相同的属性和功能的对象的抽象的集合。类名称首字母大写。多个单词则各个首字母大写；对外公开的方法需要用‘public’修饰符。
Prototype模式
03-22
NULL 博文链接：https://gary0416.iteye.com/blog/904124
设计模式---原型(Prototype)模式
honor_zhang的博客
09-22 490
1 定义 原型模式是使用一个类实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个实例对象本身来创建一个新的实例。 2 类图 抽象原型类（Prototype）:它是声明克隆方法的接口，是所有具体原型类的公共父类，它可以是接口，抽象类甚至是一个具体的实现类。 具体原型类（ConcretePrototype）：它实现了抽象原型类中声明的克隆方法，在克隆方法中返回一个自己的克隆对象。 客户类（Client）：在客户类中，使用.
Prototype 模式
weixin_30414305的博客
04-28 90
Prototype 模式提供了一个通过已存在对象进行新对象创建的接口（Clone） ，Clone（）实现和具体的实现语言相关，在 C++中我们将通过拷贝构造函数实现之。 ////////////////Prototype.h/////// #ifndef _PROTOTYPE_H_ #define _PROTOTYPE_H_ class Prototype { pub...
设计模式：Prototype(原型模式)
TuringQi
08-01 277
Prototype(原型模式) 原型（Prototype）模式的定义如下：   用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节 模式的结构  原型模式包含以下主要角色。 抽象原型类：规定了具体原型对象必须实现的接口 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象 访问类：使用具体原型类中的 clone() 方法来复制新的对象 //具体原型类 cl
设计模式：原型模式（Prototype）
weixin_33901843的博客
03-25 151
 原型模式：用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。  举个例子： 1 原型（实际上是implements了Cloneable接口，进而重写clone()方法） public class ProtoType implements Cloneable { private String name; ...
设计模式-Prototype模式（原型模式）
weixin_44030848的博客
07-24 1261
图解设计模式中的原型模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值