java设计模式 GOF23 04 原型模式

一.原型模式介绍

  因为java中new一个新对象比clone一个对象需要花费等多的资源，所以一般需要

在短时间内创建大量对象并且new对象的过程需要耗费比较多的资源使用原型模式。

 

想要clone一个类需要这个类实现Cloneable接口，重载clone方法，这个接口在底层

通过内存拷贝实现clone对象，因此效率很高。

 

package com.lz.prototype; import java.util.Date; public class ShallowClone implements Cloneable{ private String name; private int age; private Date date; public ShallowClone() { } public ShallowClone(String name, int age, Date date) { super(); this.name = name; this.age = age; this.date = date; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Date getDate() { return date; } public void setDate(Date date) { this.date = date; } @Override protected Object clone() throws CloneNotSupportedException { Object obj = super.clone(); return obj; } }

package com.lz.prototype; import java.util.Date; public class ShallowTest { public static void main(String[] args) { ShallowClone sc1 = new ShallowClone("laro", 20, new Date()); System.out.println(sc1); System.out.println(sc1.getName()); System.out.println(sc1.getAge()); System.out.println(sc1.getDate()); ShallowClone sc2 = null; try { sc2 = (ShallowClone) sc1.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); } sc1.setDate(new Date()); System.out.println(sc2); System.out.println(sc2.getName()); System.out.println(sc2.getAge()); System.out.println(sc2.getDate()); } }

二.原型模式效率检测

下面是一个简单的效率测试

package com.lz.prototype; 
public class Efficiency { public static void main(String[] args) throws CloneNotSupportedException { test01(); T s = new T(); test02(s); } public static void test01() { long start = System.currentTimeMillis(); for ( int i=0; i<1000; i++ ) { T s = new T(); } long end = System.currentTimeMillis(); System.out.println((end-start)+"毫秒"); } public static void test02(T s) throws CloneNotSupportedException { long start = System.currentTimeMillis(); for ( int i=0; i<1000; i++ ) { T copy = (T) s.clone(); } long end = System.currentTimeMillis(); System.out.println((end-start)+"毫秒"); } } class T implements Cloneable{ public T() { try { Thread.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } }

 

三.浅拷贝与深拷贝

下面是一个简单代码实现当然上面的代码只实现了浅拷贝，浅拷贝的含义是只clone这个对象本身，而这个类里面包含的其他引用对象并没有

实现clone。这里想要实现深拷贝需要改动代码

package com.lz.prototype;

import java.util.Date;

public class DeepClone implements Cloneable{
    private String name;
    private int age;
    private Date date;
    public DeepClone() {
    }
    
    public DeepClone(String name, int age, Date date) {
        super();
        this.name = name;
        this.age = age;
        this.date = date;
    }
    

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    /*
     * 实现深拷贝
     * @see java.lang.Object#clone()
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();
        DeepClone dc = (DeepClone) obj;
        dc.date = (Date) this.date.clone();
        return obj;
    }
}

简单的实现深clone很简单，只需要将需要clone的类的内部的引用类也clone即可。

但是这种方法在比较复杂的类中就不容易实现了，这里还可以使用序列化和反序列化实现clone

当然一个类想实现序列化和反序列话需要实现Serializable接口

下面是一个简单的代码实现：

 

package com.lz.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Date;

/*
 * 序列化反序列化clone对象
 */
public class Test01 {
    public static void main(String[] args) throws Exception {
        Sheep s1 = new Sheep("tom", new Date(1000000000L));
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(s1);
        byte[] bytes = bos.toByteArray();
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(bis);
        Sheep s2 = (Sheep) ois.readObject();
        System.out.println("测试前");
        System.out.println(s1);
        System.out.println(s1.getName()+" " + s1.getBirthday());
        System.out.println(s2);
        System.out.println(s2.getName()+" " + s2.getBirthday());
        
        s1.setName("laro");
        s1.setBirthday(new Date(1000000000L));
        
        System.out.println("测试后");
        System.out.println(s1);
        System.out.println(s1.getName()+" " + s1.getBirthday());
        System.out.println(s2);
        System.out.println(s2.getName()+" " + s2.getBirthday());
    }
}


class Sheep implements Cloneable, Serializable{
    private String name;
    private Date birthday;
    public Sheep() {
    }
    public Sheep(String name, Date birthday) {
        super();
        this.name = name;
        this.birthday = birthday;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}