（@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();
         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());
     }
 }

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

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

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