大话设计模式读书笔记（七） 原型模式

原型模式（Prototype）：

书中通过小菜要去面试，需要打印简历。而引出了需求。 需要小菜写一份简历类，要求有姓名，年龄，性别。可以设置工作经历，并且需要三份简历。

未使用设计模式代码：

package Prototype.NoPattern;

public class Resume {
    private String name;//姓名
    private int age; //年龄
    private String sex; //性别
    
    private String timeAree; //工作时长
    private String company; //公司
    
    public void setPersonInfo(int age,String sex){//设置个人信息
        this.age = age;
        this.sex = sex;
    }
    
    public void setWorkExperience(String timeAree,String company){//设置工作经历
        this.timeAree = timeAree;
        this.company = company;
    }
    
    public void display(){//显示
        System.out.println(name+"  "+age+"  "+sex);
        System.out.println("工作经历："+company +";工作年限:"+timeAree);
    }
    public Resume(String name) {
        super();
        this.name = name;
    }
}

 

主程序代码：

public class Main {
    public static void main(String[] args) {
        Resume a = new Resume("大鸟");
        a.setPersonInfo(25, "男");
        a.setWorkExperience("2008-2010", "xx公司");
        
        Resume b = new Resume("大鸟");
        b.setPersonInfo(25, "男");
        b.setWorkExperience("2008-2010", "xx公司");
        
        Resume c = new Resume("大鸟");
        c.setPersonInfo(25, "男");
        c.setWorkExperience("2008-2010", "xx公司");
        
        a.display();
        b.display();
        c.display();
    }
}

 

按照大鸟的话来说，这就相当于 在以前没有打印的年代，手写代码一样。 当需要三份简历的时候，就需要些三次，如果需要二十份，则需要实例化二十次。而且当有一个地方出现错误的时候，需要改20处。很显然这样是很不好的。于是引出了设计模式：原型模式。

原型模式（Prototype）：

原型模式：用原型实例制定创建类型的种类，并通过克隆这些原型创建新的对象。

原型模式UML类图：

 

源代码：

public interface Prototype extends Cloneable{//抽象克隆对象
    public Object clone();
}

 

public class ConcretePrototype implements Prototype{//具体克隆对象    
    public Object clone(){//最简单的克隆方法，由于没有属性就不复制值了
        Prototype prototype = new ConcretePrototype();
        return prototype;
    }
}

 

public class Client {
    private Prototype prototype;//持有需要使用的原型接口对象

    public Client(Prototype prototype) {//构造方法，需要传入一个需要克隆的对象
        super();
        this.prototype = prototype;
    }
    public Prototype operation(){
        ConcretePrototype concretePrototype =(ConcretePrototype) prototype.clone();
        return concretePrototype ;
    }
}

 

Java中的克隆：

Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其他对象的引用也同时会被复制一份

　　Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。

克隆满足的条件：

clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：

1.在派生类中覆盖基类的clone()方法，并声明为public【Object类中的clone()方法为protected的】。 
2.在派生类的clone()方法中，调用super.clone()。 
3.在派生类中实现Cloneable接口。 

克隆后的对象与原对象比较：

　　（1）对任何的对象x，都有：x.clone()!=x。换言之，克隆对象与原对象不是同一个对象。

　　（2）对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。

　　（3）如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。

　　在JAVA语言的API中，凡是提供了clone()方法的类，都满足上面的这些条件。JAVA语言的设计师在设计自己的clone()方法时，也应当遵守着三个

条件。一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的。

利用原型模式实现简历打印：

public class Resume implements Cloneable{
    private String name;
    private int age;
    private String sex;
    
    private String timeAree;
    private String company;
    
    public void setPersonInfo(int age,String sex){
        this.age = age;
        this.sex = sex;
    }
    
    public void setWorkExperience(String timeAree,String company){
        this.timeAree = timeAree;
        this.company = company;
    }
    
    public void display(){
        System.out.println(name+"  "+age+"  "+sex);
        System.out.println("工作经历："+company +";工作年限:"+timeAree);
    }
    
    public Resume() {
        super();
    }
    
    public Resume(String name) {
        super();
        this.name = name;
    }
    
    public Resume(String name, int age, String sex, String timeAree, String company) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        this.timeAree = timeAree;
        this.company = company;
    }
public Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
 
public class Client {//打印方法，通过该方法实现克隆简历，相当于打印功能
    Resume resume ;

    public Client(Resume resume) {
        super();
        this.resume = resume;
    }
    
    public Resume getResume() throws CloneNotSupportedException{
        return  (Resume)resume.clone();
    }
}

 

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException{
        Resume resume = new Resume("小菜");
        resume.setPersonInfo(18, "男");
        resume.setWorkExperience("2016-2017", "XX公司");
        Client c = new Client(resume);
        
        Resume resume2=c.getResume();
        Resume resume3=c.getResume();
        resume.display();
        resume2.display();
        resume3.display();
    }
}

 

深克隆与潜克隆：

A:浅复制（浅克隆）: 浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 
b:深复制（深克隆）：深复制把要复制的对象所引用的对象都复制了一遍。

浅克隆示例：

public class Dept implements Cloneable{//部门
    String id;
    String name;
    public Dept(String id, String name) {
        this.id = id;
        this.name = name;
    }
    
    public Dept clone() throws CloneNotSupportedException{
        return (Dept) super.clone();
    }
}

public class Emp implements Cloneable{
    String name ; 
    String id;
    Dept dept;
    public Emp(String name, String id, Dept dept) {
        super();
        this.name = name;
        this.id = id;
        this.dept = dept;
    }
    public Emp clone() throws CloneNotSupportedException{
        return (Emp) super.clone();
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        Dept d = new Dept("1", "技术部");
        Dept d2 = d.clone();
        System.out.println(d == d2);
        
        Emp e = new Emp("小明", "1", d);
        Emp e2 = e.clone();
        
        System.out.println(e==e2);
        System.out.println(e.dept==e2.dept);
    }
}

 

结果为：

false
false 
true

因为浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 所以复制员工时，员工所引用的部门还是原来员工的部门。

如果要深复制，则只需要将员工中的clone方法修改成如下:

public class Emp implements Cloneable{
    String name ; 
    String id;
    Dept dept;
    public Emp(String name, String id, Dept dept) {
        super();
        this.name = name;
        this.id = id;
        this.dept = dept;
    }
    public Emp clone() throws CloneNotSupportedException{
        Emp emp = (Emp) super.clone();
        emp.dept=dept.clone();
        return emp;
    }
}

 

 

也就是在复制员工的同时，将员工所在的部门同时复制一遍。这就进行了深复制。

通过序列化实现深克隆：

public class Dept implements Serializable{
    private static final long serialVersionUID = 6798532648769041110L;
    String id;
    String name;
    public Dept(String id, String name) {
        this.id = id;
        this.name = name;
    }
}

 

public class Emp implements Serializable{
    String name ; 
    String id;
    Dept dept;
    public Emp(String name, String id, Dept dept) {
        super();
        this.name = name;
        this.id = id;
        this.dept = dept;
    }
    public Object deepClone() throws Exception{
        //将该对象序列化成流,因为写在流里的是对象的一个拷贝，
        //而原对象仍然存在于JVM里面。所以利用这个特性可以实现对象的深拷贝 
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        //将流序列化成对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

 

public class Main {
    public static void main(String[] args) throws Exception {
        Dept d = new Dept("1", "技术部");
        
        Emp e = new Emp("小明", "1", d);
        Emp e2 = (Emp) e.deepClone();
        
        System.out.println(e==e2);
        System.out.println(e.dept==e2.dept);
    }
}

 

此时，输出的结果一样是false,false.