（@WhiteTaken）设计模式学习——原型模式

有这样一个需求，两个对象，只是名称以及其他几个属性不一样，而其他的大部分的属性都是相同的。

这时候我们可以用到原型模式，也就是克隆模式。

原型模式：原型模式是一个对象创建型模式，通过克隆原对象，可以使新对象的数据与原对象数据保持一致。

原型模式是由原对象发起的，创建新对象的方法。

原对象与新对象具备一样的数据结构以及一样的值。

克隆模式有浅层克隆和深层克隆之分（主要体现在对引用对象的处理不同）

直接上代码。

1.创建一个书类，书有几个属性，名称，书页数，出版单位，作者等。

2.实现克隆模式，java的话需要实现cloneable接口

3.在类中实现克隆的方法，本例中有浅层克隆和深层克隆两种方法。区别在于对引用对象的处理。

import java.util.ArrayList;
import java.util.List;

public class Book implements Cloneable{　　//原型模式需要实现cloneable接口
    private String name;
    private int number;
    private String company;
    private List<String> author;　　　　　　//指向的是一个引用的空间
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    public String getCompany() {
        return company;
    }
    public void setCompany(String company) {
        this.company = company;
    }
    
    public List<String> getAuthor() {
        return author;
    }
    public void setAuthor(List<String> author) {
        this.author = author;
    }
    
    //浅层克隆，clone以后引用会保持一致，当引用对象发生改变，两个克隆对象就会发生改变
    public Book ShallowClone(){
        try {
            return (Book) super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }
    //深度克隆，需要对有引用的地方进行操作
    public Book DepthClone(){
        try {
            Book book=(Book)super.clone();
            List<String> authors=new ArrayList<String>();
            for(String author:this.getAuthor()){
                authors.add(author);
            }
            book.setAuthor(authors);
            return book;
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }    
    }
}

4.主客户端测试代码

import java.util.ArrayList;
import java.util.List;

//原型模式也叫克隆模式
public class MainClass {
    public static void main(String[] args) {
        Book book1=new Book();            　　　　　　//实例化一个book1
        book1.setName("shujujiegou");
        book1.setNumber(100);
        book1.setCompany("TomCompany");
        List<String>author=new ArrayList<>();
        author.add("Tom");
        author.add("WhiteTaken");
        book1.setAuthor(author);
        
        Book book2=book1.ShallowClone();　　　　　　　　//实例化一个book2,调用book1的浅层克隆方法
        book1.setName("数据结构");　　　　　　　　　　　　//浅层克隆，引用指向同一个，但是String等类型的值直接克隆
        author.add("Langer");　　　　　　　　　　　　　　//修改book1的值，浅层克隆book1和book2指向的是同一个引用，打印的值相同
    
        System.out.println(book1.getName());
        System.out.println(book1.getNumber());
        System.out.println(book1.getCompany());    
        System.out.println(book1.getAuthor());
        
        System.out.println(book2.getName());
        System.out.println(book2.getNumber());
        System.out.println(book2.getCompany());
        System.out.println(book2.getAuthor());
        
        System.out.println("==================");
        
        Book book3=book1.DepthClone();　　　　　　　　　　//实例化一个book3,调用book1的深层克隆方法
        author.add("KZMASTER");　　　　　　　　　　　　　　//修改book1的引用值，book3没有变化
        System.out.println(book1.getAuthor());
        System.out.println(book3.getAuthor());
    }
}

应用场景：在某些情况下，被创建的对象，不仅仅想拥有其基类的数据结构，也想继承其基类的数据，这时候可以考虑原型模式。

深度克隆，可以保证原对象和克隆出来的新对象，完全互不影响

克隆的方法是在对象类中实现的。