原型模式 prototype

简介: 1 定义:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节 2 实现方式:通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
1 定义:用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.允许一个对象再创建另外一个可定制的对象,根本无需知道任何如何创建的细节
2 实现方式: 通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
3 使用情况:很多时候,创建对象的时候,只是在某些属性值上有区别,而大部分都很相似,该类的用户对于该类的对象是怎么创建的,对类的内部结构这些都不关心的情况,但是这样的对象的初始化相对来说比较复杂,      而且需要耗费较长的时间或资源,这种情况下,我们可以考虑使用Prototype模式。
4 原型模式 prototype-(浅度克隆):浅克隆是指克隆一个对象,而该对象的属性只是基本数据类型,只克隆出该对象!
eg:
 1 package com.lovo.prototype.two;
 2 public class Player implements Cloneable {
 3 
 4     private int id;
 5     private String name;
 6     private String skill;
 7 
 8     public int getId() {
 9         return id;
10     }
11     public void setId(int id) {
12         this.id = id;
13     }
14     public String getName() {
15         return name;
16     }
17     public void setName(String name) {
18         this.name = name;
19     }
20     public String getSkill() {
21         return skill;
22     }
23     public void setSkill(String skill) {
24         this.skill = skill;
25     }
26     
27     
28 @Override
29     public String toString() {
30         return "Player [id=" + id + ", name=" + name + ", skill=" + skill + "]";
31     }
32     
33     /**
34      * 浅克隆
35      * @return
36      * @throws CloneNotSupportedException
37      */
38     public Player qianClone() throws CloneNotSupportedException{
39         return (Player) super.clone();
40     }
41     
42     
43     
44     
45 
46 }

 

 1 package com.lovo.prototype.two;
 2 
 3 public class Test {
 4 
 5     public static void main(String[] args) throws CloneNotSupportedException {
 6         Player p=new Player();
 7         p.setId(1);
 8         p.setName("小明");
 9         p.setSkill("灌篮");
10         
11         Player p2=p.qianClone();
12         
13         System.out.println(p);
14         System.out.println("=============");
15         System.out.println(p2);
16         System.out.println(p==p2);//fasle
17         
18     }
19 
20 }

 

 
5 原型模式 prototype-(深度克隆):深度克隆是指克隆的目标里面还有引用类型,引用类型里还有引用类型,同时把引用类型克隆出来叫深度克隆!
 
 1 package com.lovo.prototype.two;
 2 
 3 import java.io.ByteArrayInputStream;
 4 import java.io.ByteArrayOutputStream;
 5 import java.io.IOException;
 6 import java.io.ObjectInputStream;
 7 import java.io.ObjectOutputStream;
 8 import java.io.Serializable;
 9 import java.util.List;
10 
11 
12 
13 public class Player implements Cloneable,Serializable {
14     private static final long serialVersionUID = 1L;
15     private int id;
16     private String name;
17     private String skill;
18     private List<String> list;
19     
20     public List<String> getList() {
21         return list;
22     }
23     public void setList(List<String> list) {
24         this.list = list;
25     }
26     public int getId() {
27         return id;
28     }
29     public void setId(int id) {
30         this.id = id;
31     }
32     public String getName() {
33         return name;
34     }
35     public void setName(String name) {
36         this.name = name;
37     }
38     public String getSkill() {
39         return skill;
40     }
41     public void setSkill(String skill) {
42         this.skill = skill;
43     }
44     
45     @Override
46     public String toString() {
47         return "Player [id=" + id + ", name=" + name + ", skill=" + skill
48                 + ", list=" + list + "]";
49     }
50     
51     
52     /**
53      * 深克隆
54      * @return
55      * @throws IOException
56      * @throws ClassNotFoundException
57      */
58     public Player deepClone() throws IOException, ClassNotFoundException{
59         ByteArrayOutputStream bos=new ByteArrayOutputStream();
60         ObjectOutputStream oos=new ObjectOutputStream(bos);
61         oos.writeObject(this);
62         
63         ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
64         ObjectInputStream ois=new ObjectInputStream(bis);
65         Player p=(Player) ois.readObject();
66         
67         
68         
69         
70         return p;
71         
72     }
73     
74 
75 }

 

 1 package com.lovo.prototype.two;
 2 
 3 import java.io.IOException;
 4 import java.util.ArrayList;
 5 import java.util.List;
 6 
 7 public class Test {
 8 
 9     public static void main(String[] args) throws CloneNotSupportedException, ClassNotFoundException, IOException  {
10         Player p=new Player();
11         p.setId(1);
12         p.setName("小明明");
13         p.setSkill("灌篮");
14         
15         Player p2=p.deepClone();
16         List<String> list=new ArrayList<>();
17         list.add("跑步");
18         list.add("射击");
19         p2.setList(list);
20           
21         
22         System.out.println(p);
23         System.out.println("=============");
24         System.out.println(p2);
25         
26     }
27 
28 }

 

 
相关文章
|
2月前
|
JavaScript 前端开发
prototype(原型对象)
原型对象(prototype)是 JavaScript 中一种特殊的对象,它用于实现对象之间的属性和方法共享。在 JavaScript 中,所有的对象都有一个原型(除了全局对象,如 Math、Date 等),当我们试图访问一个对象的属性或方法时,如果该对象本身没有这个属性或方法,Jav
9 1
|
11月前
|
设计模式 缓存 Java
java设计模式-原型模式(PrototypePattern)
java设计模式-原型模式(PrototypePattern)
|
设计模式 存储 Java
详解Java设计模式之原型模式(Prototype Pattern)
详解Java设计模式之原型模式(Prototype Pattern)
230 0
详解Java设计模式之原型模式(Prototype Pattern)
|
安全 Java
创建型模式 - 原型模式(Prototype Pattern)
创建型模式 - 原型模式(Prototype Pattern)
|
设计模式 缓存 Java
《一天一个设计模式》------原型模式(Prototype)
《一天一个设计模式》------原型模式(Prototype)
80 0
《一天一个设计模式》------原型模式(Prototype)
|
设计模式 Java
设计模式-Prototype原型模式
设计模式-Prototype原型模式
设计模式-Prototype原型模式
|
设计模式 fastjson Java
创建型-Prototype
1. 什么是原型模式? 如果对象的创建成本比较大,而同一个类的不同对象之间差别不大(大部分字段都相同),在这种情况下,我们可以利用对已有对象(原型)进行复制(或者叫拷贝)的方式,来创建新对象,以达到节省创建时间的目的。这种基于原型来创建对象的方式就叫作原型设计模式,简称原型模式。
92 0
|
设计模式 Java
浅谈JAVA设计模式之——原型模式(Prototype)
用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象。
159 0
浅谈JAVA设计模式之——原型模式(Prototype)
|
设计模式 Java 编译器
JAVA设计模式(05):创建型-原型模式(Prototype)
转自:http://blog.csdn.net/lovesomnus/article/details/23755505
140 0
JAVA设计模式(05):创建型-原型模式(Prototype)
|
Java 安全 设计模式
设计模式五: 原型模式(Prototype)
简介 原型模式是属于创建型模式的一种,是通过拷贝原型对象来创建新的对象. 万能的Java超类Object提供了clone()方法来实现对象的拷贝. 可以在以下场景中使用原型模式: 构造函数创建对象成本太大(性能或安全成本) 要保存对象的状态, 且状态变化较小, 不会过多占用内存时(状态变化较大的使用状态模式会更合适) 意图 使用原型实例指定要创建的对象类型,并通过拷贝这个原型来创建新对象。
930 0