Wie zu werfen einen Iterator der Klasse einen Iterator, der einer Subklasse?

Versuchte ich warf einen Iterator der Klasse einen iterator, der eine Unterklasse der Klasse sagte. Dies gab mir ein "inconvertible types" Fehler. Warum ist dies nicht möglich, und was ist der eleganteste Weg das zu umgehen? (Oder alternativ, warum ist es eine schlechte Idee, wenn es ist?)

Mithilfe einer for-each-Schleife ist keine Lösung in diesem Fall: ich bin versucht zu implementieren iterator() und der einfachste Weg, dies zu tun wäre, um die Rückkehr der iterator() einer meiner Klasse " Felder, aber dass man nicht über den gewünschten Typ. Ich kann es nicht ändern, die Signatur von meinem iterator()entweder.

public interface SomeoneElsesInterface {
    public Iterator<SomeoneElsesInterface> iterator();
}

public abstract class MyAbstractClass implements SomeoneElsesInterface {
    final MyAbstractClass[] things;
    public MyAbstractClass(SomeoneElsesInterface... things) {
         this.things = (MyAbstractClass[]) things;
    }
}

public class MyClass extends MyAbstractClass {
    public MyClass(MyAbstractClass thing1, MyAbstractClass thing2) {
        super(thing1, thing2);
    }

    public Iterator<SomeoneElsesInterface>() {
        return (Iterator<SomeoneElsesInterface>) Arrays.asList(things).iterator();
    }
}

Konnte ich, natürlich, ändern Sie einfach die Art von things. Jedoch bräuchte ich eine Menge von Besetzungen in anderen Orten, in diesem Fall. Ich weiß, dass mein Konstruktor nicht aufgerufen werden, mit Gegenständen, die nicht MyAbstractClasss, aber ich kann nicht ändern das interface sowieso.

  • Was (wenn überhaupt etwas) ist die Beziehung zwischen dem Typ der Klasse und der Art der enthaltenen Feld? Können Sie uns zeigen, einige code?
InformationsquelleAutor Erik | 2012-07-15
  1. 4

    Sieht dies so einfach wie mit explizite Typ-argument Spezifikation:

    public class MyClass extends MyAbstractClass {
    //...

    public Iterator<SomeoneElsesInterface> iterator() {
      return Arrays.<SomeoneElsesInterface>asList(things).iterator();
    }
}

    Das problem ist, dass Arrays#asList() ist abzuleiten, dass eine Liste vom Typ List<MyAbstractClass>, die Ausbeute wird ein iterator vom Typ Iterator<MyAbstractClass>. Da Iterator's type-parameter ist nicht kovariante, die Sie nicht liefern kann eine Iterator<MyAbstractClass> wo ein Iterator<SomeoneElsesInterface> erforderlich ist. Durch erzwingen Arrays#asList() zum erstellen einer Liste von Typ List<SomeoneElsesInterface>, wie oben gezeigt, werden Sie auch wind-up mit der beabsichtigten iterator-Typ kommen zurück von Ihrem Aufruf Iterable#iterator().

    Autor SomeoneElsesInterface gewesen wäre, kinder angeben, die Rückkehr der Typ der iterator() Methode als Iterator<? extends SomeoneElsesInterface>.

    InformationsquelleAutor seh
  2. 5

    Ich denke, aus Ihrer Frage, die Sie versuchen zu tun, so etwas wie dieses:

    Iterator<Object> original = ...
Iterator<String> converted = (Iterator<String>)original;

    Ist das richtig?

    Wenn ja, das ist leider unmöglich. Das problem ist, dass original können Objekte enthalten, die nicht Strings, so so dass dass cast brechen würden den Generika-Vertrag, d.h. converted enthalten könnte etwas, das nicht ein String.

    Ich glaube nicht, dass es einen eleganten workaround für dieses.

    Ihnen sagen, die einfachste Möglichkeit zum implementieren von iterator() ist, um eine Instanz-Feld iterator, so dass ich vermute, Sie haben so etwas wie dieses:

    class IterableThing implements Iterable<Foo> {
    private Collection<Bar> someStuff;

    public Iterator<Foo> iterator() {
        return (Iterator<Foo>)someStuff.iterator();
    }
}

class Bar {
}
class Foo extends Bar {
}

    Wenn someStuff gewährleistet werden kann, enthält nur Instanzen von Foo, dann können Sie erklären someStuff eine Collection<Foo> eher als eine Collection<Bar>? Wenn nicht, dann ist es nicht wirklich sinnvoll, nur zurück someStuff's iterator, weil es könnte etwas beinhalten, das nicht ein Foo.

    Ich denke, Sie müssen denken, über welche Garantien kann man tatsächlich machen. Wenn Sie nicht garantieren können, dass someStuff enthält nur Foos, dann werden Sie wahrscheinlich haben, um Ihren eigenen Zustand, oder filtern Sie den Inhalt der someStuff auf Nachfrage.

    EDIT: hast Du aktualisiert, deine Frage mit code. Genial.

    So wie es aussieht bist du tatsächlich versuchen, zurück einen iterator über die Oberklasse der Typ. Das macht die Dinge viel einfacher.

    In Ihrem speziellen Fall, können Sie wahrscheinlich lösen es mit diesem:

    return Arrays.<SomeoneElsesInterface>asList(things).iterator();

    Es generieren werden einige Warnungen, aber das ist OK, weil Sie wissen, dass Sie garantiert haben Art Sicherheit.

    • Im wesentlichen, ja. Aber in meinem Fall original ist eigentlich ein Iterator von Subclass, und ich will converted eine Iterator einer Oberklasse von Subclass. Ich kann daher garantieren, dass original nur Elemente enthält, die (transitiv) von Instanzen der Klasse.
    InformationsquelleAutor Cameron Skinner
  3. 1

    Verwenden for-each loop statt Iterator.

    for-each wurde von Java 1.5

    Siehe diesen link für weitere details:

    http://docs.oracle.com/javase/1.5.0/docs/guide/language/foreach.html

    InformationsquelleAutor Kumar Vivek Mitra
  4. 0

    Was, wenn Sie ändern Arrays.asList(things) zu Arrays.asList((SomeoneElsesInterface[]) things)? Sobald das array cast in den richtigen Typ der Liste und Iterator Folgen sollten.

    InformationsquelleAutor Alan Stokes
  5. -1

    Beispiel von Java for-each (Ergänzung Kumar Antwort):

    List<String> strings = new ArrayList<String>();
strings.add( "one" );
strings.add( "two" );
strings.add( "three" );

for ( String item : strings ) {
    System.out.println( item );
}
    InformationsquelleAutor davidbuzatto
Schreibe einen Kommentar