Board logo

标题: 【分享】Effective Java核心实战编程思想-猴王的把戏 [打印本页]

作者: 流星的美    时间: 2009-9-9 16:25     标题: 【分享】Effective Java核心实战编程思想-猴王的把戏

不知道大家还记不记得在《西游记》里的莲花洞夺宝的故事,就是猴王巧夺宝物,收复金银角大王那一章。到底这个故事给了我们什么启示呢?这故事又和Effective Java有什么联系?还是延续上篇文章的风格吧,看代码,读故事。
    1import static 链接标记org.junit.Assert.*;
  2import org.junit.Test;
  3
  4
  5public 链接标记class TestClone {
  6
  7    @Test
  8    public void testClone(){
  9        // 西天取经的路上,金角大王和银角大王把唐僧抓走了
  10        猴王 齐天大圣=new 猴王("齐天大圣孙悟空");
  11        //大圣手拿金箍棒,正要收拾金、银角大王。
  12        齐天大圣.取得武器(new 金箍棒());
  13
  14        /**//*
  15         * 这时候,金角大王和银角大王听闻大圣来者不善,立马让小妖去请出他们的宝葫芦
  16         * 当然这一切瞒不过神通广大的大圣爷。大圣猴毛一吹,变出一个老道士。
  17         */
  18        猴王 空悟孙道士=(猴王)齐天大圣.变出一个化身();
  19        空悟孙道士.改名("空悟孙道士");
  20
  21        /**//*
  22         * 老道士忽悠小妖说他的葫芦更厉害,能把天都给收了,智力值只有20的小妖看了羡慕不已,要求交换葫芦。
  23         * 老道士自然很乐意,换了葫芦,直奔妖怪洞穴,收服了金、银角大王。
  24         */
  25        空悟孙道士.取得武器(new 宝葫芦());
  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    class 猴王 implements Cloneable{
  49        private String name;
  50        private 武器[] weapon=new 武器[1];
  51
  52        public 猴王(String name){
  53            this.name=name;
  54        }
  55
  56        /** *//**
  57         * 取得一个猴王的浅克隆化身
  58         * @return
  59         */
  60        public Object 变出一个化身(){
  61            Object cloneObj=null;
  62            try{
  63                cloneObj=clone();
  64            }catch(CloneNotSupportedException ex){
  65                ex.printStackTrace();
  66            }
  67            return cloneObj;
  68        }
  69
  70        @Override
  71        protected Object clone() throws CloneNotSupportedException{
  72            return super.clone();
  73        }
  74
  75        public String 名字() {
  76            return name;
  77        }
  78
  79        public void 改名(String name){
  链接标记80            this.name=name;
  81        }
  82
  83        public 武器 的武器() {
  84            return weapon[0];
  85        }
  86
  87        public void 取得武器(武器 weapon) {
  88            this.weapon[0] = weapon;
  89        }
  90    }
  91
  92    class 武器{
  93        public 武器(){
  94
  95        }
  96    }
  97
  98    class 金箍棒 extends 武器{
  99        public 金箍棒(){
  100        }
  101    }
  102
  103    class 宝葫芦 extends 武器{
  104        public 宝葫芦(){
  105        }
  106    }
  107
  108
  109}
  110

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




欢迎光临 【3.A.S.T】网络安全爱好者 (http://3ast.com./) Powered by Discuz! 7.2