ITPub博客

首页 > 应用开发 > IT综合 > 原型模式(Prototype)

原型模式(Prototype)

原创 IT综合 作者:Diy_os 时间:2017-06-08 15:43:58 0 删除 编辑

原型模式顾名思义,以一个对象为原型,进行克隆,复制操作,产生一个和原型相似的对象。下面用的例子是以Java中浅拷贝和深拷贝为例。

浅拷贝:被克隆对象的所有变量都与原来对象有相同的值,而所有的对其他对象的引用仍然指向原来的对象。

上面说的很抽象,下面通过简单堆栈图描述:(图与示例代码相对应,man对象在person类中被引用)


深拷贝:被克隆对象的所有变量都与原来的对象有相同的值,除去那些引用其他对象的变量。那些引用其他对象的变量将指向被克隆过的新对象,而不再是原有的那些被引用的对象。


示例代码:

  1. public class Man implements Cloneable{  
  2.     private String name;  
  3.     private int age;  
  4.     Man m;  
  5.     public Man(int age,String name){  
  6.         this.age = age;  
  7.         this.name = name;  
  8.     }  
  9.     public Object clone(){  
  10.         try {  
  11.           m  = (Man) super.clone();  
  12.         } catch (CloneNotSupportedException e) {  
  13.             e.printStackTrace();  
  14.         }  
  15.         return m;  
  16.     }  
  17.     public void  setAge(int age){  
  18.         this.age = age;  
  19.     }  
  20.     public void setName(String name){  
  21.         this.name = name;  
  22.     }  
  23.     public int getAge(){  
  24.         return age;  
  25.     }  
  26.     public String getName(){  
  27.         return name;  
  28.     }  
  29. }  
  1. public class Person implements Cloneable {  
  2.     private int age;  
  3.     private String name;  
  4.      Man man;  
  5.     String address = new String("CQ");  
  6.     public Person(int age,String name,Man man){  
  7.         this.age = age;  
  8.         this.name = name;  
  9.         this.man = man;  
  10.     }  
  11.     /* 
  12.      *浅拷贝 
  13.      */  
  14.     public Person clone(){  
  15.         Person person = null;  
  16.         try {  
  17.             person = (Person) super.clone();  
  18.         }catch (CloneNotSupportedException e){  
  19.             e.printStackTrace();  
  20.         }  
  21.         return person;  
  22.     }  
  23.     /* 
  24.      *深拷贝 
  25.      */  
  26.     public Person deepclone(){  
  27.         Person person = null;  
  28.         try{  
  29.             person = (Person)super.clone();  
  30.             person.man = (Man)person.man.clone();//同样拷贝引用的对象  
  31.         }catch (CloneNotSupportedException e){  
  32.             e.printStackTrace();  
  33.         }  
  34.         return person;  
  35.     }  
  36.   
  37.     public void setAge(int age){  
  38.         this.age = age;  
  39.     }  
  40.     public void setName(String name){  
  41.         this.name = name;  
  42.     }  
  43.     public int getAge(){  
  44.         return age;  
  45.     }  
  46.     public String getName(){  
  47.         return name;  
  48.     }  
  49.     public static void main(String[] args){  
  50.         Man man = new Man(1,"Man");  
  51.         /* 
  52.          *浅拷贝 
  53.          */  
  54.         System.out.print("拷贝前Man:\n"+"age="+man.getAge()+",name="+man.getName()+"\n");  
  55.         Person person = new Person(2,"Person",man);  
  56.         System.out.print("拷贝前Person:\n"+"age="+person.getAge()+",name="+person.getName()+"\n");  
  57.   
  58.         Person person1 = person.clone();  
  59.   
  60.         person1.setAge(22);  
  61.         person1.setName("Person222");  
  62.         person1.man.setAge(11);  
  63.         person1.man.setName("Man11");  
  64.         System.out.print("拷贝前Man:\n"+"age="+man.getAge()+",name="+man.getName()+"\n");  
  65.         System.out.print("拷贝后Man:\n"+"age="+person1.man.getAge()+",name="+person1.man.getName()+"\n");//Man引用拷贝后对值得修改,影响到修改之前的值  
  66.         System.out.print("拷贝后Person:\n"+"age="+person1.getAge()+",name="+person1.getName()+"\n");  
  67.   
  68.       /* 
  69.        *深拷贝 
  70.        */  
  71.         System.out.println("=================================================");  
  72.         Man mandeep = new Man(1,"Man");  
  73.         Person persondeep = new Person(2,"Person",mandeep);  
  74.         Person person2 = person.deepclone();  
  75.         System.out.print("深拷贝前Man:\n"+"age="+mandeep.getAge()+",name="+mandeep.getName()+"\n");  
  76.         System.out.print("深拷贝前Person:\n"+"age="+person.getAge()+",name="+person.getName()+"\n");  
  77.         person2.setAge(22);  
  78.         person2.setName("Person222");  
  79.         person2.man.setAge(11);  
  80.         person2.man.setName("Man11");  
  81.         System.out.print("深拷贝前Man:\n"+"age="+mandeep.getAge()+",name="+mandeep.getName()+"\n");  
  82.         System.out.print("深拷贝后Man:\n"+"age="+man.getAge()+",name="+man.getName()+"\n");  
  83.         System.out.print("深拷贝后Person:\n"+"age="+person1.getAge()+",name="+person2.getName()+"\n");  
  84.     }  
  85. }  
实现对象的复制很简单,实现Cloneable接口,然后调用super.clone(),即可实现。上面实现深拷贝时,还可以用串行化实现。注意被克隆对象与克隆出的对象是!=,但是类类型是一样的。
关于java的深克隆和浅克隆详细介绍可参考:http://blog.csdn.net/pony_maggie/article/details/52091588

来自 “ ITPUB博客 ” ,链接:http://blog.itpub.net/29876893/viewspace-2140453/,如需转载,请注明出处,否则将追究法律责任。

请登录后发表评论 登录
全部评论

注册时间:2014-12-11

  • 博文量
    159
  • 访问量
    985100