Effective Java核心实战编程思想

　　不知道大家还记不记得在西游记里莲花洞夺宝故事就是猴王巧夺宝物收复金银角大王那章到底这个故事给了我们什么启示呢?这故事又和Effective Java有什么联系?还是延续上篇文章风格吧看代码读故事


　 1import org.junit.Assert.*;
　　2import org.junit.Test;
　　3
　　4
　　5public TestClone {
　　6
　　7　　　 @Test
　　8　　　 public void testClone{
　　9　　　　　　　 // 西天取经路上金角大王和银角大王把唐僧抓走了
　　10　　　　　　　 猴王 齐天大圣= 猴王("齐天大圣孙悟空");
　　11　　　　　　　 //大圣手拿金箍棒正要收拾金、银角大王
　　12　　　　　　　 齐天大圣.取得武器( 金箍棒);
　　13
　　14　　　　　　　 /**//*
　　15　　　　　　　　 * 这时候金角大王和银角大王听闻大圣来者不善立马让小妖去请出他们宝葫芦
　　16　　　　　　　　 * 当然这切瞒不过神通广大大圣爷大圣猴毛吹变出个老道士
　　17　　　　　　　　 */
　　18　　　　　　　 猴王 空悟孙道士=(猴王)齐天大圣.变出个化身;
　　19　　　　　　　 空悟孙道士.改名("空悟孙道士");
　　20
　　21　　　　　　　 /**//*
　　22　　　　　　　　 * 老道士忽悠小妖说他葫芦更厉害能把天都给收了智力值只有20小妖看了羡慕不已要求交换葫芦
　　23　　　　　　　　 * 老道士自然很乐意换了葫芦直奔妖怪洞穴收服了金、银角大王
　　24　　　　　　　　 */
　　25　　　　　　　 空悟孙道士.取得武器( 宝葫芦);
　　26
　　27　　　　　　　 //问题1:道士拿是什么武器?道士是由大圣克隆而来拿却不是金箍棒而是宝葫芦?
　　28　　　　　　　 assertFalse(齐天大圣.武器 instanceof 金箍棒);
　　29　　　　　　　 assertTrue(空悟孙道士.武器 instanceof 宝葫芦);
　　30
　　31　　　　　　　 //问题2:大圣和道士拿同个武器?
　　32　　　　　　　 assertSame(空悟孙道士.武器,齐天大圣.武器);
　　33
　　34　　　　　　　 //问题3:既然武器是样为什么名字又不样呢?
　　35　　　　　　　 assertEquals(齐天大圣.名字,"齐天大圣孙悟空");
　　36　　　　　　　 assertEquals(空悟孙道士.名字,"空悟孙道士");
　　37
　　38　　　　　　　 /**//*
　　39　　　　　　　　 * 答案:猴王类继承了Object.clone其克隆原理是:如果类每个域包含个原语类型(primitive)值
　　40　　　　　　　　 * 或者包含个指向非可变(final)对象引用那么返回值或对象是个相同拷贝;否则如果是可变类则会返回相同引用
　　41　　　　　　　　 * 金箍棒类不是非可变类而String是所以你应该明白为什么大圣爷和他克隆体有区别名字却有相同武器吧
　　42　　　　　　　　 *
　　43　　　　　　　　 * Object.clone被称为浅拷贝或浅克隆相对应是深克隆(deep clone)他是指类在克隆时也拷贝可变对象
　　44　　　　　　　　 * 看到这里你应该知道其实这个猴王类实现得不合理他应该拥有个深克隆思路方法
　　45　　　　　　　　 */
　　46　　　 }
　　47
　　48　　　 猴王 implements Cloneable{
　　49　　　　　　　 private String name;
　　50　　　　　　　 private 武器 weapon= 武器[1];
　　51
　　52　　　　　　　 public 猴王(String name){
　　53　　　　　　　　　　　 this.name=name;
　　54　　　　　　　 }
　　55
　　56　　　　　　　 /** *//**
　　57　　　　　　　　 * 取得个猴王浅克隆化身
　　58　　　　　　　　 * @
　　59　　　　　　　　 */
　　60　　　　　　　 public Object 变出个化身{
　　61　　　　　　　　　　　 Object cloneObj=null;
　　62　　　　　　　　　　　 try{
　　63　　　　　　　　　　　　　　　 cloneObj=clone;
　　64　　　　　　　　　　　 }catch(CloneNotSupportedException ex){
　　65　　　　　　　　　　　　　　　 ex.prStackTrace;
　　66　　　　　　　　　　　 }
　　67　　　　　　　　　　　 cloneObj;
　　68　　　　　　　 }
　　69
　　70　　　　　　　 @Override
　　71　　　　　　　 protected Object clone throws CloneNotSupportedException{
　　72　　　　　　　　　　　 super.clone;
　　73　　　　　　　 }
　　74
　　75　　　　　　　 public String 名字 {
　　76　　　　　　　　　　　 name;
　　77　　　　　　　 }
　　78
　　79　　　　　　　 public void 改名(String name){
　　80　　　　　　　　　　　 this.name=name;
　　81　　　　　　　 }
　　82
　　83　　　　　　　 public 武器 武器 {
　　84　　　　　　　　　　　 weapon[0];
　　85　　　　　　　 }
　　86
　　87　　　　　　　 public void 取得武器(武器 weapon) {
　　88　　　　　　　　　　　 this.weapon[0] = weapon;
　　89　　　　　　　 }
　　90　　　 }
　　91
　　92　　　 武器{
　　93　　　　　　　 public 武器{
　　94
　　95　　　　　　　 }
　　96　　　 }
　　97
　　98　　　 金箍棒 extends 武器{
　　99　　　　　　　 public 金箍棒{
　　100　　　　　　　 }
　　101　　　 }
　　102
　　103　　　 宝葫芦 extends 武器{
　　104　　　　　　　 public 宝葫芦{
　　105　　　　　　　 }
　　106　　　 }
　　107
　　108
　　109}
　　110

　　看到这里你应该对深克隆和浅克隆有了初步了解了吧?现在我们再看怎样深克隆个猴王哦不对应该是真正猴王 7十 2变(为什么我叫他猴王孙悟空有歧义)

　
　1import org.junit.Assert.assertEquals;
　　2import org.junit.Assert.assertFalse;
　　3import org.junit.Assert.assertNotSame;
　　4import org.junit.Assert.assertTrue;
　　5
　　6import org.junit.Test;
　　7
　　8
　　9public TestDeepClone {
　　10
　　11　　　 @Test
　　12　　　 public void testDeepClone{
　　13　　　　　　　 // 西天取经路上金角大王和银角大王把唐僧抓走了
　　14　　　　　　　 猴王 齐天大圣= 猴王("齐天大圣孙悟空");
　　15　　　　　　　 //大圣手拿金箍棒正要收拾金、银角大王
　　16　　　　　　　 齐天大圣.取得武器( 金箍棒);
　　17
　　18　　　　　　　 /**//*
　　19　　　　　　　　 * 这时候金角大王和银角大王听闻大圣来者不善立马让小妖去请出他们宝葫芦
　　20　　　　　　　　 * 当然这切瞒不过神通广大大圣爷大圣猴毛吹变出个老道士
　　21　　　　　　　　 */
　　22　　　　　　　 猴王 空悟孙道士=(猴王)齐天大圣.变出个化身;
　　23　　　　　　　 空悟孙道士.改名("空悟孙道士");
　　24
　　25　　　　　　　 /**//*
　　26　　　　　　　　 * 老道士忽悠小妖说他葫芦更厉害能把天都给收了智力值只有20小妖看了羡慕不已要求交换葫芦
　　27　　　　　　　　 * 老道士自然很乐意换了葫芦直奔妖怪洞穴收服了金、银角大王
　　28　　　　　　　　 */
　　29　　　　　　　 齐天大圣.取得武器( 宝葫芦);
　　30
　　31
　　32　　　　　　　 assertTrue(空悟孙道士.武器 instanceof 金箍棒);
　　33　　　　　　　 assertFalse(空悟孙道士.武器 instanceof 宝葫芦);
　　34　　　　　　　 assertNotSame(空悟孙道士.武器,齐天大圣.武器);
　　35　　　　　　　 assertEquals(齐天大圣.名字,"齐天大圣孙悟空");
　　36　　　　　　　 assertEquals(空悟孙道士.名字,"空悟孙道士");
　　37　　　 }
　　38
　　39　　　 猴王 implements Cloneable{
　　40　　　　　　　 private String name;
　　41　　　　　　　 private 武器 weapon;
　　42
　　43　　　　　　　 public 猴王(String name){
　　44　　　　　　　　　　　 this.name=name;
　　45　　　　　　　 }
　　46
　　47　　　　　　　 /** *//**
　　48　　　　　　　　 * 取得个猴王浅克隆化身
　　49　　　　　　　　 * @
　　50　　　　　　　　 */
　　51　　　　　　　 public Object 变出个化身{
　　52　　　　　　　　　　　 Object cloneObj=null;
　　53　　　　　　　　　　　 try{
　　54　　　　　　　　　　　　　　　 cloneObj=clone;
　　55　　　　　　　　　　　 }catch(CloneNotSupportedException ex){
　　56　　　　　　　　　　　　　　　 ex.prStackTrace;
　　57　　　　　　　　　　　 }
　　58　　　　　　　　　　　 cloneObj;
　　59　　　　　　　 }
　　60
　　61　　　　　　　 /** *//**
　　62　　　　　　　　 * 取得个猴王深克隆化身
　　63　　　　　　　　 * @
　　64　　　　　　　　 */
　　65　　　　　　　 public Object 变出个新化身{
　　66　　　　　　　　　　　 Object cloneObj=null;
　　67　　　　　　　　　　　 try{
　　68　　　　　　　　　　　　　　　 cloneObj=clone;
　　69　　　　　　　　　　　 }catch(CloneNotSupportedException ex){
　　70　　　　　　　　　　　　　　　 ex.prStackTrace;
　　71　　　　　　　　　　　 }
　　72　　　　　　　　　　　 cloneObj;
　　73　　　　　　　 }
　　74
　　75　　　　　　　 @Override
　　76　　　　　　　 protected Object clone throws CloneNotSupportedException{
　　77　　　　　　　　　　　 super.clone;
　　78　　　　　　　 }
　　79
　　80　　　　　　　 public String 名字 {
　　81　　　　　　　　　　　 name;
　　82　　　　　　　 }
　　83
　　84　　　　　　　 public void 改名(String name){
　　85　　　　　　　　　　　 this.name=name;
　　86　　　　　　　 }
　　87
　　88　　　　　　　 public 武器 武器 {
　　89　　　　　　　　　　　 weapon;
　　90　　　　　　　 }
　　91
　　92　　　　　　　 public void 取得武器(武器 weapon) {
　　93　　　　　　　　　　　 this.weapon = weapon;
　　94　　　　　　　 }
　　95　　　 }
　　96
　　97　　　 abstract 武器 implements Cloneable{
　　98　　　　　　　 public 武器{
　　99
　　100　　　　　　　 }
　　101
　　102　　　　　　　 @Override
　　103　　　　　　　 public Object clone{
　　104　　　　　　　　　　　 Object result=null;
　　105　　　　　　　　　　　 try{
　　106　　　　　　　　　　　　　　　 result= super.clone;
　　107　　　　　　　　　　　 }catch(CloneNotSupportedException ex){
　　108　　　　　　　　　　　　　　　 ex.prStackTrace;
　　109　　　　　　　　　　　 }
　　110　　　　　　　　　　　 result;
　　111　　　　　　　 }
　　112　　　 }
　　113
　　114　　　 金箍棒 extends 武器{
　　115　　　　　　　 public 金箍棒{
　　116　　　　　　　 }
　　117
　　118　　　　　　　 @Override
　　119　　　　　　　 public Object clone{
　　120　　　　　　　　　　　 super.clone;
　　121　　　　　　　 }
　　122　　　 }
　　123
　　124　　　 宝葫芦 extends 武器{
　　125　　　　　　　 public 宝葫芦{
　　126　　　　　　　 }
　　127
　　128　　　　　　　 @Override
　　129　　　　　　　 public Object clone{
　　130　　　　　　　　　　　 super.clone;
　　131　　　　　　　 }
　　132　　　 }
　　133}
　　134

延伸阅读