Generische Interfaces und die Folgen

Hallo,

ich habe folgendes Problem:

public interface Tree<T>
{
  //...
  void add( Tree<T> tree );
}

Dieses interface wird folgendermaßen implementiert:

public GeneralTree<T> implements Tree<T>
{
  //...
  public void add( GeneralTree<T> tree ); //*
}

Bei * gibt es (natürlich) einen Fehler, da die Signaturen der Methoden

void add( Tree<T> tree );

und

void add( GeneralTree<T> tree );

nicht identisch sind.

Was ich eigentlich erreichen möchte, ist, dass * als Implementierung der add-Methode angesehen wird, d.h. ich möchte dass der Tree nur aus Knoten besteht, die denselben Typ wie der Wurzelknoten haben.

Ich hoffe es ist einigermaßen klar geworden.
Kann mir jemand auf die Sprünge helfen?

Danke.

DEvent

Ich verstehe den Sinn von deiner

void add( Tree<T> tree );

sowieso nicht. Ein Baum besteht normalerweise aus Knoten, die selbst wiederrum Knoten und die Referenz auf den Root-Knoten enthalten. Also z.B. so

class Tree {
    Node root;
    List<Node> children;

    public void addNode(Node node);
}

Nun kannst du entweder Node als Interface, Klasse oder als einen generischen Parameter implementieren.

Eine void add( Tree<T> tree );-methode wuerde nur Sinn machen, wenn sie alle Knoten des anderen Baumes in diesen Baum einfuegen wuerde.

DEvent schrieb:

Eine void add( Tree<T> tree );-methode wuerde nur Sinn machen, wenn sie alle Knoten des anderen Baumes in diesen Baum einfuegen wuerde.

Hallo,

genau das sollte sie tun bzw. einen anderen baum (des gleichen typs) als teilbaum einfügen.

Dasd

Hab's jetzt nicht intensiv getestet, aber möglich ist zum Beispiel sowas:

public interface Tree<TreeType extends Tree<TreeType, ElementType>, ElementType> {
		void add(TreeType tree);
	}

	public class GeneralTree<T> implements Tree<GeneralTree<T>, T> {
		@Override
		public void add(GeneralTree<T> tree) {
		}
	}

Dasd schrieb:

Hab's jetzt nicht intensiv getestet, aber möglich ist zum Beispiel sowas:

public interface Tree<TreeType extends Tree<TreeType, ElementType>, ElementType> {
		void add(TreeType tree);
	}
	
	public class GeneralTree<T> implements Tree<GeneralTree<T>, T> {
		@Override
		public void add(GeneralTree<T> tree) {
		}
	}

Hallo,

das wäre das was ich möchte, aber:

das geht ja (wie ich ja bereits geschrieben habe) eben nicht (ich habe es sogar nochmal eben probiert), weil

public void add(GeneralTree<T> tree)

nicht

void add(TreeType tree);

implementiert.

anonymus maximus schrieb:

Dasd schrieb:
Hab's jetzt nicht intensiv getestet, aber möglich ist zum Beispiel sowas:
public interface Tree<TreeType extends Tree<TreeType, ElementType>, ElementType> {
		void add(TreeType tree);
	}
	
	public class GeneralTree<T> implements Tree<GeneralTree<T>, T> {
		@Override
		public void add(GeneralTree<T> tree) {
		}
	}
Hallo,

das wäre das was ich möchte, aber:

das geht ja (wie ich ja bereits geschrieben habe) eben nicht (ich habe es sogar nochmal eben probiert), weil
public void add(GeneralTree<T> tree)
nicht
void add(TreeType tree);
implementiert.

Hoppla, streich das, mein Fehler. Ist schon spät.

Hallo,
das hat nichts mit generics zu tun, du kannst in einer implementierung eines interfaces oder in einer unterklasse nicht die parametertypen überschriebener methoden weiter einschränken, als sie in der oberklasse/interface definiert sind, sonst macht die hierarchie ja keinen sinn.

knivil

sowieso nicht. Ein Baum besteht normalerweise aus Knoten, die selbst wiederrum Knoten und die Referenz auf den Root-Knoten enthalten.

Ich implementiere Baeume nie so.