java设计模式（五）—— 原型模式

原型模式的本质是Java中的克隆技术，以某个对象为原型，复制出新的对象。

通过原型模式创建的克隆对象属性值完全和原型对象相同，并且克隆出的信对象不会改变影响原型对象。

原型模式的实现

  (浅克隆)

Cloneable接口和clone方法。

一般而言，clone()方法满足：

　　1. 克隆对象与原对象不是同一个对象。即对任何的对象x：

　　x.clone() != x

　　2.克隆对象与原对象的类型一样。即对任何的对象x：

　　x.clone().getClass() == x.getClass()

（深拷贝）

1 序列化和反序列化实现clone 

2 所有属性（属性过多的话过于复杂）

都实现java.lang.Cloneable接口

都重写java.lang.Object.clone()方法

 

 

Spring 中的bean的创建实际就是两种：单例模式和原型模式。

深克隆和浅克隆

Object 的clone(）方法实现的是浅克隆，要实现深克隆需要重写clone（）方法，在该方法中对属性中的引用对象也进行克隆。

浅克隆和深克隆

测试：

执行结果：

com.hh.prototype.Sheep@2a139a55

com.hh.prototype.Sheep@15db9742

Sun Mar 21 08:20:34 CST 26579

结果说明：

通过直接调用Object的clone()方法，创建了2个不同的对象，但是修改其中一个对象的属性的时候，另一个对象的属性也发生了改变。

Thu Jan 01 08:20:34 CST 1970 //s2的date没有发生改变

原型模式构建对象和 new 对象效率比较

采用原型模式创建对象200次耗时：0

采用new创建对象200次耗时：2057

所以，通过原型模式创建对象，可以大大提高创建的效率，直接克隆，避免了重新执行构造过程。原型模式和工厂模式搭配起来，是常用的使用方式。

 

（深拷贝）--序列化

通过序列化方式实现深拷贝：先将要拷贝对象写入到内存中的字节流中，然后再从这个字节流中读出刚刚存储的信息，作为一个新对象返回，那么这个新对象和原对象就不存在任何地址上的共享，自然实现了深拷贝。

自定义类需要实现Serializable接口。

import java.io.*;
 
/**
 * 深拷贝和浅拷贝的测试
 * 如何利用序列化来完成对象的拷贝呢？在内存中通过字节流的拷贝是比较容易实现的。把母对象写入到一个字节流中，再从字节流中将其读出来，
 * 这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。
 */
//工具类
class CloneUtil{
        public static <T extends Serializable> T clone(T obj){
                T cloneObj=null;
                try{
                        //写入字节流
                        ByteArrayOutputStream baos=new ByteArrayOutputStream();
                        ObjectOutputStream oos=new ObjectOutputStream(baos);
                        oos.writeObject(obj);
                        oos.close();
 
                        //分配内存,写入原始对象,生成新对象
                        ByteArrayInputStream bais=new ByteArrayInputStream(baos.toByteArray());//获取上面的输出字节流
                        ObjectInputStream ois=new ObjectInputStream(bais);
 
                        //返回生成的新对象
                        cloneObj=(T)ois.readObject();
                        ois.close();
                }catch (Exception e){
                       e.printStackTrace();
                }
                return cloneObj;
        }
}
 
//测试类1
class Person implements Serializable{
        String name;
        int age;
        Person(String name,int age){
                this.name=name;
                this.age=age;
        }
 
}
//测试类2
 
class Animal implements Serializable{
        Person host;//主人
        int age;//年纪
        Animal(Person person,int age){
                this.host=person;
                this.age=age;
        }
}
 
 
//测试
public class Main{
        public static void main(String[] args) {
                System.out.println("----------------深拷贝--------------");
                //重写Object的clone方法,实现深拷贝
                //还是用==查看两个对象的内存地址是否相等来确定是否为两个对象,如果是两个内存地址,那么就是深拷贝
                Animal animal1=new Animal(new Person("cxh",26),3);
                Animal animal2=CloneUtil.clone(animal1);
                System.out.println("animal1和animal2的host内存地址是否相同:"+(animal1.host==animal2.host));
        }
}