12.3 克隆的控制

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（独子）方案。

//: CheckCloneable.java // Checking to see if a handle can be cloned
// Can't clone this because it doesn't // override clone(): class Ordinary {}
// Overrides clone, but doesn't implement // Cloneable: class WrongClone extends Ordinary { public Object clone() throws CloneNotSupportedException { return super.clone(); // Throws exception } }
// Does all the right things for cloning: class IsCloneable extends Ordinary implements Cloneable { public Object clone() throws CloneNotSupportedException { return super.clone(); } }
// Turn off cloning by throwing the exception: class NoMore extends IsCloneable { public Object clone() throws CloneNotSupportedException { throw new CloneNotSupportedException(); } }
class TryMore extends NoMore { 
  public Object clone() throws CloneNotSupportedException { // Calls NoMore.clone(), 
    throws exception: return super.clone(); 
  } 
}
class BackOn extends NoMore { 
  private BackOn duplicate(BackOn b) { // Somehow make a copy of b // and return that copy. This is a dummy // copy, just to make the point: 
    return new BackOn(); 
  } 
  public Object clone() { // Doesn't call NoMore.clone(): 
    return duplicate(this); 
  } 
}
// Can't inherit from this, so can't override // the clone method like in BackOn: final class ReallyNoMore extends NoMore {}
public class CheckCloneable { 
  static Ordinary tryToClone(Ordinary ord) { 
    String id = ord.getClass().getName(); 
    Ordinary x = null; 
    if(ord instanceof Cloneable) { 
      try { 
        System.out.println("Attempting " + id); 
        x = (Ordinary)((IsCloneable)ord).clone(); 
        System.out.println("Cloned " + id);
      } catch(CloneNotSupportedException e) { 
        System.out.println( "Could not clone " + id);
      }
    }
    return x;
  } 
  public static void main(String[] args) {
    // Upcasting: 
    Ordinary[] ord = { 
      new IsCloneable(), new WrongClone(), new NoMore(), new TryMore(), new BackOn(), new ReallyNoMore()
    }; 
    Ordinary x = new Ordinary(); // This won't compile, since clone() is // protected in Object: //! x = (Ordinary)x.clone(); // tryToClone() checks first to see if // a class implements Cloneable: 
    for(int i = 0; i < ord.length; i++) 
      tryToClone(ord[i]);
  }
} 
///:~

//: CopyConstructor.java // A constructor for copying an object // of the same type, as an attempt to create // a local copy.
class FruitQualities { 
  private int weight; 
  private int color; 
  private int firmness; 
  private int ripeness; 
  private int smell; // etc. 
  FruitQualities() { // Default constructor // do something meaningful... 
  } 
  // Other constructors: // ... // Copy constructor: 
  FruitQualities(FruitQualities f) { 
    weight = f.weight; 
    color = f.color; 
    firmness = f.firmness; 
    ripeness = f.ripeness; 
    smell = f.smell; // etc. 
  } 
}
class Seed { // Members... 
  Seed() { 
    /* Default constructor */ 
  }
  Seed(Seed s) { 
    /* Copy constructor */
  }
}
class Fruit { 
  private FruitQualities fq; 
  private int seeds; 
  private Seed[] s; 
  Fruit(FruitQualities q, int seedCount) { 
    fq = q; 
    seeds = seedCount; 
    s = new Seed[seeds];
    for(int i = 0; i < seeds; i++) 
      s[i] = new Seed(); 
  } 
    // Other constructors: // ... // Copy constructor: 
   Fruit(Fruit f) {
     fq = new FruitQualities(f.fq); 
     seeds = f.seeds; // Call all Seed copy-constructors: 
     for(int i = 0; i < seeds; i++) 
       s[i] = new Seed(f.s[i]); // Other copy-construction activities... 
    } // To allow derived constructors (or other // methods) to put in different qualities: 
    protected void addQualities(FruitQualities q) { 
      fq = q; 
    } 
    protected FruitQualities getQualities() { 
      return fq; 
    } 
  }
class Tomato extends Fruit { 
  Tomato() { 
    super(new FruitQualities(), 100); 
  } 
  Tomato(Tomato t) { 
    // Copy-constructor 
    super(t);
    // Upcast for base copy-constructor 
    // Other copy-construction activities... 
  }
}
class ZebraQualities extends FruitQualities { 
  private int stripedness; 
  ZebraQualities() { 
    // Default constructor 
    // do something meaningful... 
  } 
  ZebraQualities(ZebraQualities z) {
    super(z);
    stripedness = z.stripedness;
  }
}
class GreenZebra extends Tomato { 
  GreenZebra() { 
    addQualities(new ZebraQualities()); 
  } 
  GreenZebra(GreenZebra g) { 
    super(g); 
    // Calls Tomato(Tomato) 
    // Restore the right qualities: 
    addQualities(new ZebraQualities()); 
  } 
  void evaluate() { 
    ZebraQualities zq = (ZebraQualities)getQualities(); 
    // Do something with the qualities // ... 
  }
}
public class CopyConstructor { 
  public static void ripen(Tomato t) { 
    // Use the "copy constructor": 
    t = new Tomato(t); 
    System.out.println("In ripen, t is a " + t.getClass().getName()); 
  } 
  public static void slice(Fruit f) { 
    f = new Fruit(f); 
    // Hmmm... will this work? 
    System.out.println("In slice, f is a " + f.getClass().getName()); 
  } 
  public static void main(String[] args) { 
    Tomato tomato = new Tomato(); 
    ripen(tomato); // OK 
    slice(tomato); // OOPS! 
    GreenZebra g = new GreenZebra(); 
    ripen(g); // OOPS! 
    slice(g); // OOPS! 
    g.evaluate(); 
  }
}
///:~

In ripen, t is a Tomato In slice, f is a Fruit In ripen, t is a Tomato In slice, f is a Fruit