Du verwendest einen veralteten Browser. Es ist möglich, dass diese oder andere Websites nicht korrekt angezeigt werden. Du solltest ein Upgrade durchführen oder ein alternativer Browser verwenden.
Muss für die Uni einige Java Klassen und Interfaces schreiben. Soweit ich die Angabe verstanden habe soll das Interface so werden dass folgendes zutrifft:
Java:
public class X implements MyInterface {
public X myMethode(X parameter) {
...
}
}
d.h. das Interface soll sicherstellen dass eine davon abgeleitete Klasse X eine Methode myMethode enthält, die als parameter und Rückgabewert denselben Datentyp wie die Klasse selbst (bzw. eine Unterklasse derselben) hat. Mein erster Ansatz ist:
Java:
public interface MyInterface {
public <X> X myMethode(X parameter);
}
Dadurch ist allerdings nicht sichergestellt dass X dann denselben Typ hat wie die Klasse!? Bitte um Hilfe!
public interface IFoo<T extends IFoo> {
public T myMethod(T parameter);
}
public class Foo implements IFoo<Foo> {
public Foo myMethod(Foo parameter);
}
public interface IFoo<T extends IFoo> {
public T myMethod(T parameter);
}
public class Foo implements IFoo<Foo> {
public Foo myMethod(Foo parameter);
}
Hm, mein Fehler. Offenstichtlich wird das ganze nicht geprüft wenn die Klasse abstract ist. Werd mal was nicht abstraktes ableiten und schaun was passiert, hehe!
Du kannst damit nur mit Klassen Parametrisieren, welche von IFoo erben. Daher auch die Upper Bound (T extends IFoo).
Integer also nicht, erbt ja nicht von IFoo.
EDIT:
Beispiel:
Java:
public interface IFoo<T extends IFoo<? super T>> {
public T myMethod(T parameter);
}
//klappt
class Foo implements IFoo<Foo> {
public Foo myMethod(Foo parameter){return null;}
}
// nix gut: Integer implementiert nicht IFoo
class BadIdea implements IFoo<Integer> {
public Integer myMethod(Integer parameter){return null;}
}
Hab jetzt folgendes Programmiert und leider noch ein Problem:
Java:
public abstract class Component implements IFoo<Component> {
...
}
public class Device extends Component {
...
}
public class Tree<A> {
...
}
public class AccTree<A extends IFoo<? super A>> extends Tree<A>
implements IFoo<AccTree<A>> {
...
}
D.h. Klasse AccTree soll als Typ nur von IFoo geerbte Klassen akzeptieren, und auch selbst IFoo implementieren. Allerdings habe ich jetzt das Problem, dass ich folgendes nicht machen kann:
Java:
AccTree<Device> x = new AccTree<Device>(new Device(10, 5));
AccTree<Component> y = x; //Fehler
Es funktioniert nicht, obwohl Device ja von Component erbt. Bitte um Hilfe!
AccTree<? extends Component> y = x; // Könnte gehen
Wobei ich zugeben muss, mich da auch nach Jahren noch (oder nach Jahren schon?!) auf den Compiler verlasse...
Ja, so funktioniert das Zuweisen. Allerdings habe ich noch folgendes Problem: Ich habe außer 'Device' auch eine Klasse 'Job' die ebenfalls von 'Component' erbt.
Nun soll ich einen AccTree<Device> und einen AccTree<Job> erzeugen. Diese soll ich dann an zwei AccTree<Component> zuweisen, und schließlich den einen Baum in den anderen einhängen, was mit der Methode 'myMethod' aus 'IFoo' passieren soll:
Java:
public class AccTree<A extends IFoo<? super A>> extends Tree<A>
implements IFoo<AccTree<A>> {
public AccTree<A> myMethod(AccTree<A> parameter) {
parameter.setParent(this);
return this;
}
...
}
Ich muss also dem Compiler beibringen, dass AccTree<Von_X_geerbt> "kompatibel" zu AccTree<X> ist... nur wie?
Ja, was heißt "kompatibel"... So wie ich das verstehe (!): Es geht nicht. Die Begründung an einem Beispiel das etwas leichter nachzuvollziehen ist, als "<A extends IFoo<? super A>> extends Tree<A>":
Java:
class Hund {}
class Dackel extends Hund {}
class Beagle extends Hund {}
Dackel dackel = new Dackel();
Beagle beagle = new Beagle();
Hund irgendeinHund = beagle;
List<Hund> hundeListe = new ArrayList<Hund>();
hundeListe.add(dackel); // Passt, jeder Dackel ist ein Hund
List<Dackel> dackelListe = new ArrayList<Dackel>();
dackelListe.add(dackel); // Passt auch
// Passt: Die dackelListe ist eine Liste von "irgendwelchen Hunden"
List<? extends Hund> irgendwelcheHundeListe = dackelListe;
// Passt: Da ist irgendein Hund drin
Hund hund = irgendwelcheHundeListe.get(0);
// Passt NICHT: Es sind zwar "irgendwelche Hunde" in der Liste,
// aber man weiß nicht, ob es Dackel sind oder andere...
irgendwelcheHundeListe.add(irgendeinHund);
Solange du keinen vollständige(re)n Quellcode postest, kann man kaum etwas sagen, was hinausgeht über: "Füge überall '? extends' ein, bis es passt" ...
Wenn du noch Zweifel hast, poste (und beschreibe) am besten mal ein KSKB, wo nur der relevante Compilerfehler auftritt - vielleicht gibt es auch eine allgemeinere oder bessere Lösung.
