Wie überschreibe ich die Klonmethode richtig?

Ich muss einen tiefen Klon in einem meiner Objekte implementieren, der keine Oberklasse hat.

Was ist der beste Weg, um mit dem CloneNotSupportedExceptionvon der Oberklasse (was ist Object) geworfenen Scheck umzugehen ?

Ein Mitarbeiter hat mir geraten, folgendermaßen damit umzugehen:

@Override
public MyObject clone()
{
    MyObject foo;
    try
    {
        foo = (MyObject) super.clone();
    }
    catch (CloneNotSupportedException e)
    {
        throw new Error();
    }

    // Deep clone member fields here

    return foo;
}

Dies scheint mir eine gute Lösung zu sein, aber ich wollte sie der StackOverflow-Community zur Verfügung stellen, um zu prüfen, ob ich weitere Erkenntnisse einschließen kann. Vielen Dank!

Müssen Sie unbedingt verwenden clone? Die meisten Leute sind sich einig, dass Java clonekaputt ist.

Josh Bloch über Design - Kopierkonstruktor versus Klonen

Wenn Sie den Artikel über das Klonen in meinem Buch gelesen haben, insbesondere wenn Sie zwischen den Zeilen lesen, werden Sie wissen, dass ich denke, dass er clonezutiefst gebrochen ist. [...] Es ist eine Schande, Cloneabledie kaputt ist, aber es passiert.

Weitere Informationen zu diesem Thema finden Sie in seinem Buch Effective Java 2nd Edition, Punkt 11: Mit Bedacht cloneüberschreiben . Er empfiehlt stattdessen die Verwendung eines Kopierkonstruktors oder einer Kopierfabrik.

Er fuhr fort, Seiten von Seiten darüber zu schreiben, wie Sie implementieren sollten, wenn Sie das Gefühl haben, dass Sie es müssen clone. Aber er schloss damit:

Ist all diese Komplexität wirklich notwendig? Selten. Wenn Sie eine Klasse erweitern , dass Geräte Cloneable, Sie kaum eine andere Wahl haben , aber eine gut erzogene zu implementieren cloneMethode. Andernfalls ist es besser, alternative Mittel zum Kopieren von Objekten bereitzustellen oder die Funktion einfach nicht bereitzustellen .

Der Schwerpunkt lag bei ihm, nicht bei mir.

Da Sie klargestellt haben, dass Sie keine andere Wahl haben, als zu implementieren clone, können Sie in diesem Fall Folgendes tun: Stellen Sie sicher, dass MyObject extends java.lang.Object implements java.lang.Cloneable. Wenn dies der Fall ist, können Sie garantieren, dass Sie NIEMALS einen fangen werden CloneNotSupportedException. Werfen, AssertionErrorwie einige vorgeschlagen haben, erscheint vernünftig, aber Sie können auch einen Kommentar hinzufügen, der erklärt, warum der catch-Block in diesem speziellen Fall niemals eingegeben wird .

Alternativ können Sie, wie andere ebenfalls vorgeschlagen haben, möglicherweise implementieren, cloneohne aufzurufen super.clone.

Manchmal ist es einfacher, einen Kopierkonstruktor zu implementieren:

public MyObject (MyObject toClone) {
}

Dies erspart Ihnen die Bearbeitung CloneNotSupportedException, arbeitet mit finalFeldern und Sie müssen sich keine Gedanken über den Typ machen, der zurückgegeben werden soll.

Die Art und Weise, wie Ihr Code funktioniert, kommt der "kanonischen" Schreibweise ziemlich nahe. Ich würde aber einen AssertionErrorin den Haken werfen . Es signalisiert, dass diese Linie niemals erreicht werden sollte.

catch (CloneNotSupportedException e) {
    throw new AssertionError(e);
}

Es gibt zwei Fälle, in denen der CloneNotSupportedExceptionWurf geworfen wird:

1. Die zu klonende Klasse wird nicht implementiert Cloneable(vorausgesetzt, das tatsächliche Klonen verschiebt sich schließlich auf die Klonmethode Object). Wenn die Klasse, in der Sie diese Methode schreiben, implementiert ist Cloneable, wird dies niemals passieren (da Unterklassen sie entsprechend erben werden).
2. Die Ausnahme wird explizit von einer Implementierung ausgelöst. Dies ist die empfohlene Methode, um die Klonbarkeit in einer Unterklasse zu verhindern, wenn sich die Oberklasse befindet Cloneable.

Der letztere Fall kann in Ihrer Klasse nicht auftreten (da Sie die Methode der Oberklasse im tryBlock direkt aufrufen , selbst wenn sie von einem Unterklassenaufruf aufgerufen wird super.clone()), und der erstere sollte dies nicht tun, da Ihre Klasse eindeutig implementieren sollte Cloneable.

Grundsätzlich sollten Sie den Fehler auf jeden Fall protokollieren, aber in diesem speziellen Fall tritt er nur auf, wenn Sie die Definition Ihrer Klasse durcheinander bringen. Behandeln Sie es also wie eine überprüfte Version von NullPointerException(oder ähnlichem) - es wird niemals ausgelöst, wenn Ihr Code funktionsfähig ist.

In anderen Situationen müssten Sie auf diese Eventualität vorbereitet sein - es gibt keine Garantie dafür, dass ein bestimmtes Objekt klonbar ist. Wenn Sie also die Ausnahme abfangen, sollten Sie abhängig von dieser Bedingung geeignete Maßnahmen ergreifen (fahren Sie mit dem vorhandenen Objekt fort und ergreifen Sie eine alternative Klonstrategie zB serialize-deserialize, werfen Sie ein, IllegalParameterExceptionwenn Ihre Methode den Parameter durch klonbar benötigt, etc. etc.).

Bearbeiten : Obwohl ich insgesamt darauf hinweisen sollte, dass es clone()wirklich schwierig ist, richtig zu implementieren, und es für Anrufer schwierig ist zu wissen, ob der Rückgabewert dem entspricht, was sie wollen, doppelt, wenn man tiefe oder flache Klone betrachtet. Es ist oft besser, das Ganze komplett zu vermeiden und einen anderen Mechanismus zu verwenden.

Verwenden Sie die Serialisierung , um tiefe Kopien zu erstellen. Dies ist nicht die schnellste Lösung, hängt jedoch nicht vom Typ ab.

Sie können geschützte Kopierkonstruktoren wie folgt implementieren:

/* This is a protected copy constructor for exclusive use by .clone() */
protected MyObject(MyObject that) {
    this.myFirstMember = that.getMyFirstMember(); //To clone primitive data
    this.mySecondMember = that.getMySecondMember().clone(); //To clone complex objects
    // etc
}

public MyObject clone() {
    return new MyObject(this);
}

So sehr die meisten Antworten hier gültig sind, muss ich sagen, dass Ihre Lösung auch so ist, wie es die tatsächlichen Java-API-Entwickler tun. (Entweder Josh Bloch oder Neal Gafter)

Hier ist ein Auszug aus der ArrayList-Klasse openJDK:

public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

Wie Sie bemerkt haben und andere erwähnt haben, CloneNotSupportedExceptionhat es fast keine Chance, geworfen zu werden, wenn Sie erklärt haben, dass Sie die CloneableSchnittstelle implementieren .

Außerdem müssen Sie die Methode nicht überschreiben, wenn Sie in der überschriebenen Methode nichts Neues tun. Sie müssen es nur überschreiben, wenn Sie zusätzliche Vorgänge für das Objekt ausführen oder es öffentlich machen müssen.

Letztendlich ist es immer noch am besten, dies zu vermeiden und es auf eine andere Weise zu tun.

public class MyObject implements Cloneable, Serializable{   

    @Override
    @SuppressWarnings(value = "unchecked")
    protected MyObject clone(){
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        try {
            ByteArrayOutputStream bOs = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bOs);
            oos.writeObject(this);
            ois = new ObjectInputStream(new ByteArrayInputStream(bOs.toByteArray()));
            return  (MyObject)ois.readObject();

        } catch (Exception e) {
            //Some seriouse error :< //
            return null;
        }finally {
            if (oos != null)
                try {
                    oos.close();
                } catch (IOException e) {

                }
            if (ois != null)
                try {
                    ois.close();
                } catch (IOException e) {

                }
        }
    }
}

Nur weil die Java-Implementierung von Cloneable fehlerhaft ist, heißt das nicht, dass Sie keine eigene erstellen können.

Wenn OP der eigentliche Zweck war, einen tiefen Klon zu erstellen, denke ich, dass es möglich ist, eine Schnittstelle wie diese zu erstellen:

public interface Cloneable<T> {
    public T getClone();
}

Verwenden Sie dann den zuvor erwähnten Prototyp-Konstruktor, um ihn zu implementieren:

public class AClass implements Cloneable<AClass> {
    private int value;
    public AClass(int value) {
        this.vaue = value;
    }

    protected AClass(AClass p) {
        this(p.getValue());
    }

    public int getValue() {
        return value;
    }

    public AClass getClone() {
         return new AClass(this);
    }
}

und eine andere Klasse mit einem AClass-Objektfeld:

public class BClass implements Cloneable<BClass> {
    private int value;
    private AClass a;

    public BClass(int value, AClass a) {
         this.value = value;
         this.a = a;
    }

    protected BClass(BClass p) {
        this(p.getValue(), p.getA().getClone());
    }

    public int getValue() {
        return value;
    }

    public AClass getA() {
        return a;
    }

    public BClass getClone() {
         return new BClass(this);
    }
}

Auf diese Weise können Sie ein Objekt der Klasse BClass problemlos tief klonen, ohne @SuppressWarnings oder anderen kniffligen Code zu benötigen.