Polymorphie Generics-Problem

[The_Unknown]

Hallo,

ich arbeite derzeit an einem kleinen Framework und habe Probleme mit den Generics.

Folgende Klassen/Interfaces habe ich:

public abstract class Root {
	
	public List<? extends RootGroup> groups;

	public List<? extends RootGroup> getGroups() {
		return groups;
	}

	public void setGroups(List<? extends RootGroup> groups) {
		this.groups = groups;
	}

}

public abstract class RootGroup {
	
	public RootGroup(String name) {
		this.name = name;
	}
	
	private String name;
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String toString() {
		return this.name;
	}

}

public class SpecialRootGroup extends RootGroup {

	public SpecialRootGroup(String name) {
		super(name);
	}

}

public class SpecialRoot extends Root {
	
	public SpecialRoot() {
		ArrayList<SpecialRootGroup> specialRootGroups = new ArrayList<SpecialRootGroup>();
		specialRootGroups.add(new SpecialRootGroup("1"));
		specialRootGroups.add(new SpecialRootGroup("2"));
		specialRootGroups.add(new SpecialRootGroup("3"));
		setGroups(specialRootGroups);
	}

}

public class Main {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		SpecialRoot specialRoot = new SpecialRoot();
		specialRoot.getGroups().add(new SpecialRootGroup("")); // Problem hier: keine Typübereinstimmung
		System.out.println(specialRoot.getGroups());
	}

}

Die Frage ist hier jetzt, warum ich in der Mainklasse keine neue SpecialRootGroup zu einer SpecialRoot hinzufügen kann, obwohl diese SpecialRootGroup ja von RootGroup erbt, was die Bedingung für den Parameter ist.

Jede Hilfe ist sehr willkommen 🙂

Bye The_Unknown

 

[Gast2]

List<? extends RootGroup>

Das ist eine Liste in der irgendwelche Objekte von Unterklassen von RootGroup drin sind. Es müssen nicht zwangsläufig SpecialRootGroup Objekte sein. Da machts natürlich Sinn, dass du nicht einfach Blind in eine solche Liste hinzufügen kannst.
Du musst den Listen einen konkreten Typ mitgeben wenn du damit arbeiten willst:

abstract class Root<E> {

	public List<E> groups;

	public List<E> getGroups() {
		return groups;
	}

	public void setGroups(List<E> groups) {
		this.groups = groups;
	}

}
[...]
class SpecialRoot extends Root<SpecialRootGroup> {

	public SpecialRoot() {
		ArrayList<SpecialRootGroup> specialRootGroups = new ArrayList<SpecialRootGroup>();
		specialRootGroups.add(new SpecialRootGroup("1"));
		specialRootGroups.add(new SpecialRootGroup("2"));
		specialRootGroups.add(new SpecialRootGroup("3"));
		setGroups(specialRootGroups);
	}

}

Ob das in deinem Anwendungsfall jetzt Sinn macht weiß ich nicht.

 

[The_Unknown]

Das funktioniert schon ganz gut, vielen Dank. Nur ein Problem habe ich damit noch: Da jetzt der Typ nur noch E ist (also ein generischer Platzhalter), habe ich in Root keinen Zugriff mehr auf RootGroup-spezifische Methoden. Bekommt man das auch irgendwie hin?

Ah, ich habs schon:

public abstract class Root<E extends RootGroup> {