第11条：谨慎的覆盖clone

Cloneable接口的目的是作为对象的一个mixin接口（mixin interface），表明这样的对象允许克隆（clone）。
遗憾的是，他并没有成功的达到这个目的。其主要的缺陷在于，他缺少一个clone方法，Object的clone方法是受保护的。
如果不借助于反射（reflection），就不能仅仅因为一个对戏那个实现了Cloneable，就可以调用clone。

demo：

view plain copy to clipboard print ?

1. importjava.util.LinkedList;
2. importjava.util.List;
4. publicclassAimplementsCloneable {
5. privateInteger id;
6. privateString name;
7. privateList<String> phones =newLinkedList<String>();
9. publicInteger getId() {
10. returnid;
11. }
12. publicvoidsetId(Integer id) {
13. this.id = id;
14. }
15. publicString getName() {
16. returnname;
17. }
18. publicvoidsetName(String name) {
19. this.name = name;
20. }
22. publicList<String> getPhones() {
23. returnphones;
24. }
25. publicvoidsetPhones(List<String> phones) {
26. this.phones = phones;
27. }
28. @Override
29. protectedA clone() {
30. try{
31. return(A)super.clone();
32. }catch(CloneNotSupportedException e) {
33. e.printStackTrace();
34. }
35. returnnull;
36. }
39. }
42. publicclassHelloWorld {
44. publicstaticvoidmain(String[] args) {
45. //cope1();
47. cope2();
48. }
50. //在不借助于BeanUtils的实例复制方法下，会出现问题，当然，原因很简单，一个指针
51. privatestaticvoidcope1() {
52. A old =newA();
53. old.setId(1);
54. old.setName("hello");
56. A n = old;
57. n.setName("world");
59. System.out.println(old.getName());
60. }
62. /**
63. * 我们让A实现了clone。但是你如果A里面含有很多可变的对象，就比较麻烦了，会引用与原来相同的数组
    
64. （BeanUtils.copyProperties也会引用与原来相同的数组）。
65. */
66. privatestaticvoidcope2() {
67. A old =newA();
68. old.setId(1);
69. old.setName("hello");
70. old.getPhones().add("da");
72. A n = old.clone();
73. n.setName("world");
74. n.getPhones().set(0,"xiao");
76. System.out.println(old.getName());
77. System.out.println(old.getPhones().get(0));
78. }
79. }

语言之外的（extralinguistic）机制：无需调用构造器就可以创建对象。

如果你覆盖了非final类中的clone方法，则应该返回一个通过调用super.clone而得到的对象。

实际上，对于实现了Cloneable的类，我们总是期望他也提供一个功能适当的公有的clone方法。
通常情况下，除非该类的所有超类都提供了行为良好的clone实现，无论是共有的还是受保护的，否则，都不可能这么做。


如果你想在一个类中实现Cloneable，首先他的超类都需要提供行为良好的clone方法。
demo：

view plain copy to clipboard print ?

1. // Adding a clone method to PhoneNumber
2. importjava.util.*;
4. publicfinalclassPhoneNumberimplementsCloneable {
5. privatefinalshortareaCode;
6. privatefinalshortprefix;
7. privatefinalshortlineNumber;
9. publicPhoneNumber(intareaCode,intprefix,
10. intlineNumber) {
11. rangeCheck(areaCode,999,"area code");
12. rangeCheck(prefix,999,"prefix");
13. rangeCheck(lineNumber,9999,"line number");
14. this.areaCode= (short) areaCode;
15. this.prefix= (short) prefix;
16. this.lineNumber = (short) lineNumber;
17. }
19. privatestaticvoidrangeCheck(intarg,intmax,
20. String name) {
21. if(arg <0|| arg > max)
22. thrownewIllegalArgumentException(name +": "+ arg);
23. }
25. @Overridepublicbooleanequals(Object o) {
26. if(o ==this)
27. returntrue;
28. if(!(oinstanceofPhoneNumber))
29. returnfalse;
30. PhoneNumber pn = (PhoneNumber)o;
31. returnpn.lineNumber == lineNumber
32. && pn.prefix== prefix
33. && pn.areaCode== areaCode;
34. }
36. @OverridepublicinthashCode() {
37. intresult =17;
38. result =31* result + areaCode;
39. result =31* result + prefix;
40. result =31* result + lineNumber;
41. returnresult;
42. }
44. /**
45. * Returns the string representation of this phone number.
46. * The string consists of fourteen characters whose format
47. * is "(XXX) YYY-ZZZZ", where XXX is the area code, YYY is
48. * the prefix, and ZZZZ is the line number.(Each of the
49. * capital letters represents a single decimal digit.)
50. *
51. * If any of the three parts of this phone number is too small
52. * to fill up its field, the field is padded with leading zeros.
53. * For example, if the value of the line number is 123, the last
54. * four characters of the string representation will be "0123".
55. *
56. * Note that there is a single space separating the closing
57. * parenthesis after the area code from the first digit of the
58. * prefix.
59. */
60. @OverridepublicString toString() {
61. returnString.format("(%03d) %03d-%04d",
62. areaCode, prefix, lineNumber);
63. }
65. @OverridepublicPhoneNumber clone() {
66. try{
67. return(PhoneNumber)super.clone();
68. }catch(CloneNotSupportedException e) {
69. thrownewAssertionError();// Can't happen
70. }
71. }
73. publicstaticvoidmain(String[] args) {
74. PhoneNumber pn =newPhoneNumber(707,867,5309);
75. Map<PhoneNumber, String> m
76. =newHashMap<PhoneNumber, String>();
77. m.put(pn,"Jenny");
78. System.out.println(m.get(pn.clone()));
79. }
80. }

上面的clone方法返回的是PhoneNumber，而不是返回的Object，要记住，必须要在返回super.clone的结果之前将它转换。


当被克隆的对象里面包含的域引用了可变的对象时：
（实际上，clone方法就是另外一个构造器；你必须确保他能不会伤害到原始的对象，并确保正确的创建被克隆对象中的约束条件-invariant）

view plain copy to clipboard print ?

1. // A cloneable version of Stack
2. importjava.util.Arrays;
4. publicclassStackimplementsCloneable {
5. privateObject[] elements;
6. privateintsize =0;
7. privatestaticfinalintDEFAULT_INITIAL_CAPACITY =16;
9. publicStack() {
10. this.elements =newObject[DEFAULT_INITIAL_CAPACITY];
11. }
13. publicvoidpush(Object e) {
14. ensureCapacity();
15. elements[size++] = e;
16. }
18. publicObject pop() {
19. if(size ==0)
20. thrownewEmptyStackException();
21. Object result = elements[--size];
22. elements[size] =null;// Eliminate obsolete reference
23. returnresult;
24. }
26. publicbooleanisEmpty() {
27. returnsize ==0;
28. }
30. @OverridepublicStack clone() {
31. try{
32. Stack result = (Stack)super.clone();
33. result.elements = elements.clone();
34. returnresult;
35. }catch(CloneNotSupportedException e) {
36. thrownewAssertionError();
37. }
38. }
40. // Ensure space for at least one more element.
41. privatevoidensureCapacity() {
42. if(elements.length == size)
43. elements = Arrays.copyOf(elements,2* size +1);
44. }
46. // To see that clone works, call with several command line arguments
47. publicstaticvoidmain(String[] args) {
48. args =newString[]{"hello","world"};
50. Stack stack =newStack();
51. for(String arg : args)
52. stack.push(arg);
53. Stack copy = stack.clone();
54. while(!stack.isEmpty())
55. System.out.print(stack.pop() +" ");
56. System.out.println();
57. while(!copy.isEmpty())
58. System.out.print(copy.pop() +" ");
59. }
60. }

注意：如果上面的demo elements域是final的，上诉方式就不能正常的工作，clone方法是禁止给elements域赋新值的。
clone架构与引用可变对象的final域的正常用法是不相兼容的。


当被克隆的对象他有自己的散列桶数组，直接克隆就会出现问题，就需要单独的拷贝，如：

view plain copy to clipboard print ?

1. 错误：
2. publicHashTable clone(){
3. HashTable result= (HashTable)super.clone();
4. result.buckets = buckets.clone();
5. returnreslut;
6. }
7. 正确：深度拷贝
8. publicHashTable clone(){
9. HashTable result= (HashTable)super.clone();
10. result.buckets =newEntry[buckets.length];
11. for(inti=0;i<buckets.length;i++){
12. if(buckets[i] !=null){
13. result.buckets[i] = buckets[i].deepCopy();
14. }
15. }
16. returnreslut;
17. }

还要考虑在拷贝的过程中线程安全的问题，把被拷贝的对象设置为不可外部修改或者实现线程安全。


最好提供某些其他的途径来代替对象拷贝，或者干脆不提供这样的功能。


另一个实现对象拷贝的好办法是提供一个拷贝构造器或拷贝工厂。