为消除克隆能力，大家也许认为只需将clone()方法简单地设为private（私有）即可，但这样是行不通的，因为不能采用一个基类方法，并使其在派生类中更“私有”。所以事情并没有这么简单。此外，我们有必要控制一个对象是否能够克隆。对于我们设计的一个类，实际有许多种方案都是可以采取的：

(1) 保持中立，不为克隆做任何事情。也就是说，尽管不可对我们的类克隆，但从它继承的一个类却可根据实际情况决定克隆。只有Object.clone()要对类中的字段进行某些合理的操作时，才可以作这方面的决定。

(2) 支持clone()，采用实现Cloneable（可克隆）能力的标准操作，并覆盖clone()。在被覆盖的clone()中，可调用super.clone()，并捕获所有异常（这样可使clone()不“抛”出任何异常）。

(3) 有条件地支持克隆。若类容纳了其他对象的引用，而那些对象也许能够克隆（集合类便是这样的一个例子），就可试着克隆拥有对方引用的所有对象；如果它们“抛”出了异常，只需让这些异常通过即可。举个例子来说，假设有一个特殊的Vector，它试图克隆自己容纳的所有对象。编写这样的一个Vector时，并不知道客户程序员会把什么形式的对象置入这个Vector中，所以并不知道它们是否真的能够克隆。

(4) 不实现Cloneable()，但是将clone()覆盖成protected，使任何字段都具有正确的复制行为。这样一来，从这个类继承的所有东西都能覆盖clone()，并调用super.clone()来产生正确的复制行为。注意在我们实现方案里，可以而且应该调用super.clone()——即使那个方法本来预期的是一个Cloneable对象（否则会抛出一个异常），因为没有人会在我们这种类型的对象上直接调用它。它只有通过一个派生类调用；对那个派生类来说，如果要保证它正常工作，需实现Cloneable。

(5) 不实现Cloneable来试着防止克隆，并覆盖clone()，以产生一个异常。为使这一设想顺利实现，只有令从它派生出来的任何类都调用重新定义后的clone()里的suepr.clone()。

(6) 将类设为final，从而防止克隆。若clone()尚未被我们的任何一个上级类覆盖，这一设想便不会成功。若已被覆盖，那么再一次覆盖它，并“抛”出一个CloneNotSupportedException（克隆不支持）异常。为担保克隆被禁止，将类设为final是唯一的办法。除此以外，一旦涉及保密对象或者遇到想对创建的对象数量进行控制的其他情况，应该将所有构造器都设为private，并提供一个或更多的特殊方法来创建对象。采用这种方式，这些方法就可以限制创建的对象数量以及它们的创建条件——一种特殊情况是第16章要介绍的singleton（单例）方案。

下面这个例子总结了克隆的各种实现方法，然后在层次结构中将其“关闭”：

  1. //: CheckCloneable.java
  2. // Checking to see if a handle can be cloned
  4. // Can't clone this because it doesn't
  5. // override clone():
  6. class Ordinary {}
  8. // Overrides clone, but doesn't implement
  9. // Cloneable:
  10. class WrongClone extends Ordinary {
  11.   public Object clone()
  12.       throws CloneNotSupportedException {
  13.     return super.clone(); // Throws exception
  14.   }
  15. }
  17. // Does all the right things for cloning:
  18. class IsCloneable extends Ordinary
  19.     implements Cloneable {
  20.   public Object clone()
  21.       throws CloneNotSupportedException {
  22.     return super.clone();
  23.   }
  24. }
  26. // Turn off cloning by throwing the exception:
  27. class NoMore extends IsCloneable {
  28.   public Object clone()
  29.       throws CloneNotSupportedException {
  30.     throw new CloneNotSupportedException();
  31.   }
  32. }
  34. class TryMore extends NoMore {
  35.   public Object clone()
  36.       throws CloneNotSupportedException {
  37.     // Calls NoMore.clone(), throws exception:
  38.     return super.clone();
  39.   }
  40. }
  42. class BackOn extends NoMore {
  43.   private BackOn duplicate(BackOn b) {
  44.     // Somehow make a copy of b
  45.     // and return that copy. This is a dummy
  46.     // copy, just to make the point:
  47.     return new BackOn();
  48.   }
  49.   public Object clone() {
  50.     // Doesn't call NoMore.clone():
  51.     return duplicate(this);
  52.   }
  53. }
  55. // Can't inherit from this, so can't override
  56. // the clone method like in BackOn:
  57. final class ReallyNoMore extends NoMore {}
  59. public class CheckCloneable {
  60.   static Ordinary tryToClone(Ordinary ord) {
  61.     String id = ord.getClass().getName();
  62.     Ordinary x = null;
  63.     if(ord instanceof Cloneable) {
  64.       try {
  65.         System.out.println("Attempting " + id);
  66.         x = (Ordinary)((IsCloneable)ord).clone();
  67.         System.out.println("Cloned " + id);
  68.       } catch(CloneNotSupportedException e) {
  69.         System.out.println(
  70.           "Could not clone " + id);
  71.       }
  72.     }
  73.     return x;
  74.   }
  75.   public static void main(String[] args) {
  76.     // Upcasting:
  77.     Ordinary[] ord = {
  78.       new IsCloneable(),
  79.       new WrongClone(),
  80.       new NoMore(),
  81.       new TryMore(),
  82.       new BackOn(),
  83.       new ReallyNoMore(),
  84.     };
  85.     Ordinary x = new Ordinary();
  86.     // This won't compile, since clone() is
  87.     // protected in Object:
  88.     //! x = (Ordinary)x.clone();
  89.     // tryToClone() checks first to see if
  90.     // a class implements Cloneable:
  91.     for(int i = 0; i < ord.length; i++)
  92.       tryToClone(ord[i]);
  93.   }
  94. } ///:~

第一个类Ordinary代表着大家在本书各处最常见到的类：不支持克隆，但在它正式应用以后，却也不禁止对其克隆。但假如有一个指向Ordinary对象的引用，而且那个对象可能是从一个更深的派生类向上转换来的，便不能判断它到底能不能克隆。

WrongClone类揭示了实现克隆的一种不正确途径。它确实覆盖了Object.clone()，并将那个方法设为public，但却没有实现Cloneable。所以一旦发出对super.clone()的调用（由于对Object.clone()的一个调用造成的），便会无情地抛出CloneNotSupportedException异常。

在IsCloneable中，大家看到的才是进行克隆的各种正确行动：先覆盖clone()，并实现了Cloneable。但是，这个clone()方法以及本例的另外几个方法并不捕获CloneNotSupportedException异常，而是任由它通过，并传递给调用者。随后，调用者必须用一个try-catch代码块把它包围起来。在我们自己的clone()方法中，通常需要在clone()内部捕获CloneNotSupportedException异常，而不是任由它通过。正如大家以后会理解的那样，对这个例子来说，让它通过是最正确的做法。

类NoMore试图按照Java设计者打算的那样“关闭”克隆：在派生类clone()中，我们抛出CloneNotSupportedException异常。TryMore类中的clone()方法正确地调用super.clone()，并解析成NoMore.clone()，后者抛出一个异常并禁止克隆。

但在已被覆盖的clone()方法中，假若程序员不遵守调用super.clone()的“正确”方法，又会出现什么情况呢？在BackOn中，大家可看到实际会发生什么。这个类用一个独立的方法duplicate()制作当前对象的一个副本，并在clone()内部调用这个方法，而不是调用super.clone()。异常永远不会产生，而且新类是可以克隆的。因此，我们不能依赖“抛”出一个异常的方法来防止产生一个可克隆的类。唯一安全的方法在ReallyNoMore中得到了演示，它设为final，所以不可继承。这意味着假如clone()在final类中抛出了一个异常，便不能通过继承来进行修改，并可有效地禁止克隆（不能从一个拥有任意继承级数的类中明确调用Object.clone()；只能调用super.clone()，它只可访问直接基类）。因此，只要制作一些涉及安全问题的对象，就最好把那些类设为final。

在类CheckCloneable中，我们看到的第一个类是tryToClone()，它能接纳任何Ordinary对象，并用instanceof检查它是否能够克隆。若答案是肯定的，就将对象转换成为一个IsCloneable，调用clone()，并将结果转换回Ordinary，最后捕获有可能产生的任何异常。请注意用运行期类型识别（见第11章）打印出类名，使自己看到发生的一切情况。

在main()中，我们创建了不同类型的Ordinary对象，并在数组定义中向上转换成为Ordinary。在这之后的头两行代码创建了一个纯粹的Ordinary对象，并试图对其克隆。然而，这些代码不会得到编译，因为clone()是Object中的一个protected（受到保护的）方法。代码剩余的部分将遍历数组，并试着克隆每个对象，分别报告它们的成功或失败。输出如下：

  1. Attempting IsCloneable
  2. Cloned IsCloneable
  3. Attempting NoMore
  4. Could not clone NoMore
  5. Attempting TryMore
  6. Could not clone TryMore
  7. Attempting BackOn
  8. Cloned BackOn
  9. Attempting ReallyNoMore
  10. Could not clone ReallyNoMore

总之，如果希望一个类能够克隆，那么：

(1) 实现Cloneable接口
(2) 覆盖clone()
(3) 在自己的clone()中调用super.clone()
(4) 在自己的clone()中捕获异常

这一系列步骤能达到最理想的效果。

12.3.1 副本构造器

克隆看起来要求进行非常复杂的设置，似乎还该有另一种替代方案。一个办法是制作特殊的构造器，令其负责复制一个对象。在C中，这叫作“副本构造器”。刚开始的时候，这好象是一种非常显然的解决方案（如果你是C程序员，这个方法就更显亲切）。下面是一个实际的例子：

  1. //: CopyConstructor.java
  2. // A constructor for copying an object
  3. // of the same type, as an attempt to create
  4. // a local copy.
  6. class FruitQualities {
  7.   private int weight;
  8.   private int color;
  9.   private int firmness;
  10.   private int ripeness;
  11.   private int smell;
  12.   // etc.
  13.   FruitQualities() { // Default constructor
  14.     // do something meaningful...
  15.   }
  16.   // Other constructors:
  17.   // ...
  18.   // Copy constructor:
  19.   FruitQualities(FruitQualities f) {
  20.     weight = f.weight;
  21.     color = f.color;
  22.     firmness = f.firmness;
  23.     ripeness = f.ripeness;
  24.     smell = f.smell;
  25.     // etc.
  26.   }
  27. }
  29. class Seed {
  30.   // Members...
  31.   Seed() { /* Default constructor */ }
  32.   Seed(Seed s) { /* Copy constructor */ }
  33. }
  35. class Fruit {
  36.   private FruitQualities fq;
  37.   private int seeds;
  38.   private Seed[] s;
  39.   Fruit(FruitQualities q, int seedCount) {
  40.     fq = q;
  41.     seeds = seedCount;
  42.     s = new Seed[seeds];
  43.     for(int i = 0; i < seeds; i++)
  44.       s[i] = new Seed();
  45.   }
  46.   // Other constructors:
  47.   // ...
  48.   // Copy constructor:
  49.   Fruit(Fruit f) {
  50.     fq = new FruitQualities(f.fq);
  51.     seeds = f.seeds;
  52.     // Call all Seed copy-constructors:
  53.     for(int i = 0; i < seeds; i++)
  54.       s[i] = new Seed(f.s[i]);
  55.     // Other copy-construction activities...
  56.   }
  57.   // To allow derived constructors (or other
  58.   // methods) to put in different qualities:
  59.   protected void addQualities(FruitQualities q) {
  60.     fq = q;
  61.   }
  62.   protected FruitQualities getQualities() {
  63.     return fq;
  64.   }
  65. }
  67. class Tomato extends Fruit {
  68.   Tomato() {
  69.     super(new FruitQualities(), 100);
  70.   }
  71.   Tomato(Tomato t) { // Copy-constructor
  72.     super(t); // Upcast for base copy-constructor
  73.     // Other copy-construction activities...
  74.   }
  75. }
  77. class ZebraQualities extends FruitQualities {
  78.   private int stripedness;
  79.   ZebraQualities() { // Default constructor
  80.     // do something meaningful...
  81.   }
  82.   ZebraQualities(ZebraQualities z) {
  83.     super(z);
  84.     stripedness = z.stripedness;
  85.   }
  86. }
  88. class GreenZebra extends Tomato {
  89.   GreenZebra() {
  90.     addQualities(new ZebraQualities());
  91.   }
  92.   GreenZebra(GreenZebra g) {
  93.     super(g); // Calls Tomato(Tomato)
  94.     // Restore the right qualities:
  95.     addQualities(new ZebraQualities());
  96.   }
  97.   void evaluate() {
  98.     ZebraQualities zq =
  99.       (ZebraQualities)getQualities();
  100.     // Do something with the qualities
  101.     // ...
  102.   }
  103. }
  105. public class CopyConstructor {
  106.   public static void ripen(Tomato t) {
  107.     // Use the "copy constructor":
  108.     t = new Tomato(t);
  109.     System.out.println("In ripen, t is a " +
  110.       t.getClass().getName());
  111.   }
  112.   public static void slice(Fruit f) {
  113.     f = new Fruit(f); // Hmmm... will this work?
  114.     System.out.println("In slice, f is a " +
  115.       f.getClass().getName());
  116.   }
  117.   public static void main(String[] args) {
  118.     Tomato tomato = new Tomato();
  119.     ripen(tomato); // OK
  120.     slice(tomato); // OOPS!
  121.     GreenZebra g = new GreenZebra();
  122.     ripen(g); // OOPS!
  123.     slice(g); // OOPS!
  124.     g.evaluate();
  125.   }
  126. } ///:~

这个例子第一眼看上去显得有点奇怪。不同水果的质量肯定有所区别，但为什么只是把代表那些质量的数据成员直接置入Fruit（水果）类？有两方面可能的原因。第一个是我们可能想简便地插入或修改质量。注意Fruit有一个protected（受到保护的）addQualities()方法，它允许派生类来进行这些插入或修改操作（大家或许会认为最合乎逻辑的做法是在Fruit中使用一个protected构造器，用它获取FruitQualities参数，但构造器不能继承，所以不可在第二级或级数更深的类中使用它）。通过将水果的质量置入一个独立的类，可以得到更大的灵活性，其中包括可以在特定Fruit对象的存在期间中途更改质量。

之所以将FruitQualities设为一个独立的对象，另一个原因是考虑到我们有时希望添加新的质量，或者通过继承与多态性改变行为。注意对GreenZebra来说（这实际是西红柿的一类——我已栽种成功，它们简直令人难以置信），构造器会调用addQualities()，并为其传递一个ZebraQualities对象。该对象是从FruitQualities派生出来的，所以能与基类中的FruitQualities引用联系在一起。当然，一旦GreenZebra使用FruitQualities，就必须将其向下转换成为正确的类型（就象evaluate()中展示的那样），但它肯定知道类型是ZebraQualities。

大家也看到有一个Seed（种子）类，Fruit（大家都知道，水果含有自己的种子）包含了一个Seed数组。

最后，注意每个类都有一个副本构造器，而且每个副本构造器都必须关心为基类和成员对象调用副本构造器的问题，从而获得“深层复制”的效果。对副本构造器的测试是在CopyConstructor类内进行的。方法ripen()需要获取一个Tomato参数，并对其执行副本构建工作，以便复制对象：

  1. t = new Tomato(t);

而slice()需要获取一个更常规的Fruit对象，而且对它进行复制：

  1. f = new Fruit(f);

它们都在main()中伴随不同种类的Fruit进行测试。下面是输出结果：

  1. In ripen, t is a Tomato
  2. In slice, f is a Fruit
  3. In ripen, t is a Tomato
  4. In slice, f is a Fruit

从中可以看出一个问题。在slice()内部对Tomato进行了副本构建工作以后，结果便不再是一个Tomato对象，而只是一个Fruit。它已丢失了作为一个Tomato（西红柿）的所有特征。此外，如果采用一个GreenZebra，ripen()和slice()会把它分别转换成一个Tomato和一个Fruit。所以非常不幸，假如想制作对象的一个本地副本，Java中的副本构造器便不是特别适合我们。

(1) 为什么在C++的作用比在Java中大？

副本构造器是C的一个基本构成部分，因为它能自动产生对象的一个本地副本。但前面的例子确实证明了它不适合在Java中使用，为什么呢？在Java中，我们操控的一切东西都是引用，而在C中，却可以使用类似于引用的东西，也能直接传递对象。这时便要用到C的副本构造器：只要想获得一个对象，并按值传递它，就可以复制对象。所以它在C里能很好地工作，但应注意这套机制在Java里是很不通的，所以不要用它。