12.2 Создание локальной копии

//: Cloning.java
// Операция клонирования работает только с некоторыми
// элементами стандартной библиотеки Java.
import java.util.*;

class Int {
  private int i;
  public Int(int ii) { i = ii; }
  public void increment() { i++; }
  public String toString() {
    return Integer.toString(i);
  }
}
``````Метод `clone()` создаёт объект `Object`, который немедленно должен быть преобразован в правильный тип. Этот пример демонстрирует, что метод `clone()` в классе `Vector` не может автоматически пытаться клонировать каждый объект внутри `Vector` — из-за проблемы с алиасами, старый `Vector` и клонированный `Vector` содержат одни и те же объекты. Обычно мы называем это "простым копированием" или "얕ой копией", так как она копирует только "поверхностные" части объекта. Реальные объекты, помимо своей "поверхности", также содержат ссылки на другие объекты, а эти объекты, в свою очередь, могут указывать на ещё более дальние объекты, и так далее. Это приводит к понятию "объектной сети" или "сети взаимосвязей объектов". Когда все связи этой сети копируются, это называется "полной копией" или "глубокой копией".
```Результаты "얕ой копии" можно видеть в выводе, обратите внимание, что действия над `v2` влияют и на `v`:

Общие правила гласят, что поскольку нельзя гарантировать, что объекты внутри `Vector` являются "клонируемыми" (Примечание ②), лучше не пытаться клонировать эти объекты.

②: "Клонируемый" на английском языке звучит как `cloneable`. Обратите внимание, что ключевое слово `cloneable` специально предусмотрено в Java библиотеке.

### 12.2.3 Делаем класс клонируемым

Хотя метод клонирования определен во всех базовых классах `Object`, он не выполняется автоматически для каждого класса. Это кажется странным, потому что методы базового класса должны быть доступны для производных классов. Однако Java работает против этого; если вы хотите использовать метод клонирования в своем классе, вам придется добавить специальный код для обеспечения его выполнения.

(1) Использование `protected`Чтобы избежать того, чтобы каждый созданный нами класс имел по умолчанию возможность клонирования, метод `clone()` был "сохранён" (установлен как `protected`) в базовом классе `Object`. В результате этого клиентские программисты, использующие этот класс, не имеют доступа к этому методу по умолчанию; кроме того, мы не можем вызвать `clone()` через ссылку на базовый класс (хотя это было бы полезно в некоторых случаях, например при использовании полиморфизма для клонирования последовательности объектов). На этапе компиляции это фактически сообщает нам, что объект не является клонируемым — и самое странное то, что большинство классов в Java библиотеке не поддерживают клонирование. Таким образом, если мы выполним следующий код:

```java
int x = new int(l);
x = x.clone();
```Тогда при компиляции появляется неприятное сообщение об ошибке, которое говорит нам, что `clone()` недоступен — потому что `Integer` не переопределяет его, а использует защищённую версию по умолчанию.

Однако, если мы находимся в классе, производном от `Object` (все классы производятся от `Object`), то имеем право вызвать `Object.clone()`, так как он является защищённым, и мы находимся внутри итератора. Базовый метод `clone()` предоставляет полезную функциональность — он выполняет "битовую" копию объекта производного класса, поэтому это эквивалентно стандартному клонированию. Однако затем нам следует сделать свой метод клонирования публичным, иначе он будет недоступен. В общем, два ключевых момента при клонировании: почти всегда следует вызывать `super.clone()`, и важно сделать клонирование публичным.Иногда может потребоваться переопределить метод `clone()` в более глубоко производном классе, и тогда можно просто использовать наш метод `clone()` (теперь сделанный публичным), но это может не быть тем, что мы хотели бы видеть (хотя, поскольку `Object.clone()` создаёт фактическую копию объекта, возможно, это допустимо). Трюк с защищённостью можно применять только один раз: первый раз, когда вы наследуетесь от класса, который не имеет возможности клонировать себя, и хотите сделать этот класс "клонируемым". А после этого, метод `clone()` становится доступным для использования во всех случаях наследования от нашего класса, так как Java не позволяет уменьшать область доступа метода после наследования. Другими словами, как только объект становится клонируемым, все производные от него объекты также становятся клонируемыми, пока не используется специальное устройство (обсуждаемое ниже), чтобы "отключить" возможность клонирования.(2) Реализация интерфейса `Cloneable`

Чтобы полностью реализовать способность объекта к клонированию, требуется ещё одно действие: реализация интерфейса `Cloneable`. Этот интерфейс кажется странным, так как он пустой!

```java
interface Cloneable {}

if (myHandle instanceof Cloneable) { // ...
}

//: LocalCopy.java
// Создание локальных копий с помощью clone()
import java.util.*;

class MyObject implements Cloneable {
  int i;
  MyObject(int ii) { i = ii; }
  public Object clone() {
    Object o = null;
    try {
      o = super.clone();
    } catch (CloneNotSupportedException e) {
      System.out.println("MyObject cannot be cloned");
    }
    return o;
  }
  public String toString() {
    return Integer.toString(i);
  }
}

public class LocalCopy {
  static MyObject g(MyObject v) {
    // Передача указателя, модифицирующего внешний объект:
    v.i++;
    return v;
  }
  static MyObject f(MyObject v) {
    v = (MyObject)v.clone(); // Локальная копия
    v.i++;
    return v;
  }
  public static void main(String[] args) {
    MyObject a = new MyObject(11);
    MyObject b = g(a);
    // Проверка эквивалентности указателей,
    // а не эквивалентности объектов:
    if(a == b)
      System.out.println("a == b");
    else
      System.out.println("a != b");
    System.out.println("a = " + a);
    System.out.println("b = " + b);
    MyObject c = new MyObject(47);
    MyObject d = f(c);
    if(c == d)
      System.out.println("c == d");
    else
      System.out.println("c != d");
    System.out.println("c = " + c);
    System.out.println("d = " + d);
  }
} ///:~
```Независимо от этого, метод `clone()` должен быть доступен, поэтому его следует сделать публичным (`public`). Вторым шагом при вызове `clone()` должно быть обращение к версии метода `clone()` базового класса. Здесь вызывается `clone()` из класса `Object`, который заранее определён. Он может быть вызван благодаря тому, что имеет свойство `protected` (защищённый), позволяющее доступ к нему из производных классов. `Object.clone()` проверяет размер исходного объекта и выделяет достаточно памяти для нового объекта, а затем копирует все двоичные биты из исходного объекта в новый объект. Это называется "битовым копированием", и обычно считается, что эта задача должна выполняться методом `clone()`. Однако перед тем как начать выполнение, `Object.clone()` сначала проверяет, реализует ли класс интерфейс `Cloneable`, то есть имеет ли он возможность клонирования. Если этот интерфейс не реализован, `Object.clone()` выбрасывает исключение `CloneNotSupportedException`, указывая, что клонировать данный объект нельзя. Поэтому лучше всего использовать блок `try-catch`, чтобы обернуть вызов `super.clone()`, попытаться захватить это исключение (которое никогда не должно возникнуть, так как здесь действительно реализован интерфейс `Cloneable`). В `LocalCopy`, два метода `g()` и `f()` демонстрируют различия в способах передачи аргументов.В частности, метод `g()` демонстрирует передачу по ссылке, которая модифицирует внешний объект и возвращает ссылку на этот внешний объект. С другой стороны, метод `f()` создает клонированную версию аргумента, отделенную от исходного объекта, и позволяет последнему оставаться независимым. Затем он продолжает выполнять свои действия, даже возвращая ссылку на новый объект без каких-либо побочных эффектов для исходного объекта.Обратите внимание на следующее несколько странное выражение:

```java
v = (MyObject) v.clone();

a == b
a = 12
b = 12
c != d
c = 47
d = 48

//: Snake.java
// Проверяет клонирование, чтобы узнать, происходит ли клонирование целевых объектов,
// на которые указывают ссылки.

public class Snake implements Cloneable {
  private Snake next;
  private char c;
  // Значение i равно количеству сегментов
  Snake(int i, char x) {
    c = x;
    if (--i > 0)
      next = new Snake(i, (char) (x + 1));
  }

  void increment() {
    c++;
    if (next != null)
      next.increment();
  }

  @Override
  public String toString() {
    String s = ":" + c;
    if (next != null)
      s += next.toString();
    return s;
  }

  @Override
  public Object clone() {
    Object o = null;
    try {
      o = super.clone();
    } catch (CloneNotSupportedException e) {
    }
    return o;
  }

  public static void main(String[] args) {
    Snake s = new Snake(5, 'a');
    System.out.println("s = " + s);
    Snake s2 = (Snake) s.clone();
    System.out.println("s2 = " + s2);
    s.increment();
    System.out.println(
        "после s.increment(), s2 = " + s2);
  }
}
///:~

s = :a:b:c:d:e
s2 = :a:b:c:d:e
после s.increment(), s2 = :a:c:d:e:f

//: DeepCopy.java
// Клонирование составного объекта

class DepthReading implements Cloneable {
  private double depth;
  public DepthReading(double depth) {
    this.depth = depth;
  }
  public Object clone() {
    Object o = null;
    try {
      o = super.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
    return o;
  }
}

class TemperatureReading implements Cloneable {
  private long time;
  private double temperature;
  public TemperatureReading(double temperature) {
    time = System.currentTimeMillis();
    this.temperature = temperature;
  }
  public Object clone() {
    Object o = null;
    try {
      o = super.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
    return o;
  }
}
``````java
class OceanReading implements Cloneable {
  private DepthReading depth;
  private TemperatureReading temperature;

  public OceanReading(double tdata, double ddata) {
    temperature = new TemperatureReading(tdata);
    depth = new DepthReading(ddata);
  }

  public Object clone() {
    OceanReading o = null;
    try {
      o = (OceanReading) super.clone();
    } catch (CloneNotSupportedException e) {
      e.printStackTrace();
    }
    // Нужно склонировать ссылки:
    o.depth = (DepthReading) o.depth.clone();
    o.temperature = (TemperatureReading) o.temperature.clone();
    return o; // Преобразование обратно в Object
  }
}

## 12.2.7 Глубокое клонирование с использованием `Vector`
```Давайте повторно рассмотрим пример с классом `Vector`, который был представлен ранее в этой главе. На этот раз класс `Int2` может быть клонирован, поэтому мы можем выполнить глубокое клонирование `Vector`:

```java
//: ДобавлениеКлонирования.java
// Для добавления возможности клонирования вам придется пройти через несколько шагов.
import java.util.*;

class Int2 implements Cloneable {
  private int i;
  public Int2(int ii) { i = ii; }
  public void увеличить() { i++; }
  public String toString() {
    return Integer.toString(i);
  }
  public Object clone() {
    Object o = null;
    try {
      o = super.clone();
    } catch (CloneNotSupportedException e) {
      System.out.println("Int2 не может быть клонирован");
    }
    return o;
  }
}

// После того как класс становится клонируемым,
// наследование не убирает возможность клонирования:
class Int3 extends Int2 {
  private int j; // Автоматически дублировано
  public Int3(int i) { super(i); }
}

public class ДобавлениеКлонирования {
  public static void main(String[] args) {
    Int2 x = new Int2(10);
    Int2 x2 = (Int2)x.clone();
    x2.увеличить();
    System.out.println(
      "x = " + x + ", x2 = " + x2);
    // Всякий наследуемый объект также является клонируемым:
    Int3 x3 = new Int3(7);
    x3 = (Int3)x3.clone();
  }
}

Вектор v = new Вектор();
for(int i = 0; i < 10; i++) 
  v.addЭлемент(new Int2(i));
System.out.println("v: " + v);
Вектор v2 = (Вектор) v.clone();
// Теперь клонируем каждый элемент:
for(int i = 0; i < v.size(); i++)
  v2.setElementAt(((Int2) v2.elementAt(i)).clone(), i);
// Увеличиваем все элементы v2:
for(Enumeration e = v2.elements(); e.hasMoreElements(); ) 
  ((Int2) e.nextElement()).increment();
// Проверяем, изменились ли элементы v:
System.out.println("v: " + v);
System.out.println("v2: " + v2);

//: Compete.java
import java.io.*;

class Thing1 implements Serializable {}
class Thing2 implements Serializable {
  Thing1 o1 = new Thing1();
}

class Thing3 implements Cloneable {
  public Object clone() {
    Object o = null;
    try {
      o = super.clone();
    } catch (CloneNotSupportedException e) {
      System.out.println("Thing3 cannot be cloned");
    }
    return o;
  }
}
``````java
class Thing4 implements Cloneable {
   Thing3 o3 = new Thing3();
   public Object clone() {
     Thing4 o = null;
     try {
       o = (Thing4) super.clone();
     } catch (CloneNotSupportedException e) {
       System.out.println("Thing4 cannot be cloned");
     }
     // Клонируем поле:
     o.o3 = (Thing3) o3.clone();
     return o;
   }
}

публичный класс Compete {
   статический константный целое SIZE = 5000;
   публичный статический метод главный(строка[] аргументы) {
     объект Thing2[] a = новый объект Thing2[SIZE];
     для(целое i = 0; i < a.длина; i++)
       a[i] = новый объект Thing2();
     объект Thing4[] b = новый объект Thing4[SIZE];
     для(целое i = 0; i < b.длина; i++)
       b[i] = новый объект Thing4();
     попробовать {
       долгое t1 = систем.currentTimeMillis();
       объект ByteArrayOutputStream buf =
         новый объект ByteArrayOutputStream();
       объект ObjectOutputStream o =
         новый объект ObjectOutputStream(buf);
       для(целое i = 0; i < a.длина; i++)
         o.writeObject(a[i]);
       // Теперь получаем копии:
       объект ObjectInputStream in =
         новый объект ObjectInputStream(
           новый объект ByteArrayInputStream(
             buf.toByteArray()));
       объект Thing2[] c = новый объект Thing2[SIZE];
       для(целое i = 0; i < c.длина; i++)
         c[i] = (Thing2) in.readObject();
       долгое t2 = систем.currentTimeMillis();
       систем.println(
         "Дублирование через сериализацию: " +
         (t2 - t1) + " миллисекунды");
       // Теперь пробуем клонирование:
       t1 = систем.currentTimeMillis();
       объект Thing4[] d = новый объект Thing4[SIZE];
       для(целое i = 0; i < d.длина; i++)
         d[i] = (Thing4) b[i].clone();
       t2 = систем.currentTimeMillis();
       систем.println(
         "Дублирование через клонирование: " +
         (t2 - t1) + " миллисекунды");
     } захватить(исключение e) {
       e.printStackTrace();
     }
   }
}
``````java
printStackTrace();
}
}

Клонирование через сериализацию: 3400 миллисекунд
Клонирование через клонирование: OnClickListener 110 миллисекунд

Клонирование через сериализацию: 3410 миллисекунд
Клонирование через клонирование: OnClickListener 110 миллисекунд

Клонирование через сериализацию: 3520 миллисекунд
Клонирование через клонирование: OnClickListener 110 миллисекунд

//: HorrorFlick.java
// Возможность клонирования может быть добавлена на любом уровне наследования.
import java.util.*;

class Person {}
class Hero extends Person {}
class Scientist extends Person implements Cloneable {
  public Object clone() {
    try {
      return super.clone();
    } catch (CloneNotSupportedException e) {
      // Это никогда не должно произойти:
      // Он уже реализует интерфейс Cloneable!
      throw new InternalError();
    }
  }
}
class MadScientist extends Scientist {}
``````java
public class HorrorFlick {
  public static void main(String[] args) {
    Person p = new Person();
    Hero h = new Hero();
    Scientist s = new Scientist();
    MadScientist m = new MadScientist();

    // p = (Person)p.clone(); // Compilation error
    // h = (Hero)h.clone(); // Compilation error
    s = (Scientist)s.clone();
    m = (MadScientist)m.clone();
  }
} ///:~