Wenn meine IDE so intelligent ist, warum muss ich dann "clone ()" umwandeln?

Mein IDE ( NetBeans ) -Typ überprüft meinen CollectionsCode, während ich ihn eingebe. Aber warum muss ich dann das zurückgegebene Objekt von werfen Object.clone()? Welches ist in Ordnung. Kein Schaden kein Foul. Aber ich verstehe es immer noch nicht.

Ist eine Typprüfung ohne Casting des zurückgegebenen Objekts Object.clone()nicht möglich? Das generische Framework lässt mich glauben, dass die IDE den Typ der Objektreferenzen auf der rechten Seite der Markierung " = " überprüfen könnte, ohne sie während des Tippens umzusetzen. Ich verstehe es nicht.

Nachtrag
Mein Anwendungsfall war nur, dass ich ein privates CalendarFeld hatte, pubdate . Ich wollte schreiben:

Calendar getPubdate() {
    return pubdate;
}

Es besteht jedoch die Gefahr, dass der Aufrufer mein Pubdate ändert , sodass ich eine Kopie zurücksende :

Calendar getPubdate() {
    return (Calendar) pubdate.clone();
}

Dann fragte ich mich, warum ich besetzen musste pubdate.clone(). Die Methodensignatur hat genau dort den Typ. NetBeans sollte dies herausfinden können. Und NetBeans schien etwas Ähnliches in Bezug auf zu tun Collections.

warum muss ich den zurückgegebenen gegenstand von werfen Object.clone()?

Weil es zurückkehrt Object.

Das generische Framework lässt mich glauben, dass die IDE den Typ der Objektreferenzen auf der rechten Seite der Markierung " = " überprüfen könnte, ohne sie während des Tippens umzusetzen. Ich verstehe es nicht.

Object.clone ist nicht generisch.

Wenn es Generika gegeben hätte, als sie cloneentworfen wurden, hätte sie wahrscheinlich so ausgesehen (unter Verwendung des F-Bounded Polymorphism):

interface Cloneable<T extends Cloneable<T>> {
  T clone();
}

Wenn Java eine MyType-Funktion hätte, würde sie möglicherweise so aussehen:

interface Cloneable {
  this clone();
}

Generics gab es jedoch nicht, als Object.clonees entworfen wurde, und Java hat keine MyTypes. Daher müssen wir mit der typunabhängigen Version von Object.clonearbeiten.

Dies ist kein Merkmal einer IDE, sondern der Sprachdefinition.

Eine IDE hilft Ihnen dabei, eine Programmiersprache effizienter zu nutzen, und ändert die Semantik dieser Sprache nicht. Das bedeutet, dass ein Editor-Helfer möglicherweise automatisch eine Besetzung einfügt, wenn klar ist, welche Sie möchten, aber nicht einfach die Regeln der Sprache brechen und so tun kann, als wäre der Code, der nicht kompiliert wurde, gültig.

Bearbeiten Es ist richtig, dass eine IDE ihren eigenen Compiler bündeln kann, und tatsächlich tun viele genau das, z. B. für eine bessere Fehlerberichterstattung mit mehr Insiderinformationen in den partiellen Analysebaum. Es wäre jedoch eine sehr schlechte Idee, diesen internen Compiler eine andere Sprachsemantik als das offizielle SDK implementieren zu lassen, da dies bedeuten würde, dass Code, der in der Entwicklung arbeitet, bei der Installation in der Produktion auf mysteriöse Weise zu Fehlern führen kann. debuggbar!

Dies liegt an der Typensignatur der Object.clone-Methode. Die Typensignatur gibt an, dass die Methode ein Objekt vom Typ Object zurückgibt.

protected Object clone() throws CloneNotSupportedException

Die Sammlungen verwenden sogenannte generische Typen, um die Art des Castings automatisch zu ersetzen.

Also, wenn Sie diesen Code haben:

List<Integer> ints = Arrays.asList(1,2,3);
int x = ints.get(0);`

Der Compiler fügt die Casts für Sie hinter den Kulissen hinzu. Der Code wäre also tatsächlich:

List ints = Arrays.asList(1,2,3);
int x = (Integer)ints.get(0);

Der Vollständigkeit halber sind seit Java 5 kovariante Rückgabetypen zulässig . Sie können also Folgendes schreiben:

public MyObject implements Cloneable {
  @Override
  public MyObject clone() {
    try {
      return (MyObject)super.clone();
    } catch (CloneNotSupportedException e) {
      throw new AssertionError();
    }
  }
}

Damit ist der folgende Code legal:

MyObject original = new MyObject();
MyObject clone = original.clone();