Datentypen Verschachtelte Generics

[Zel2491]

Moin moin,

ich bearbeite gerade eine kleine Aufgabe zum parametrisierten Polymorphismus mit Graphen und Colored Graphen.
Ich habe eine Oberklasse Graph und 2 davon erbende Klassen NodeColoredGraph und EdgeColoredGraph:

public class Graph {

	class Node {

	}

	class Edge {
		private Node n1, n2;

		public Edge(Node n1, Node n2) {
			this.n1 = n1;
			this.n2 = n2;
		}

		public Edge connect(Node n1, Node n2) {
			return new Edge(n1, n2);
		}

		public Node getN1() {
			return n1;
		}

		public Node getN2() {
			return n2;
		}
	}

	static class NodeColoredGraph<T extends Graph> extends Graph {
		private String color;

		public NodeColoredGraph(String color) {
			this.color = color;
		}

		public String getNodeColor() {
			return color;
		}

		public void setNodeColor(String color) {
			this.color = color;
		}

		@Override
		public String toString() {
			return "Der NodeColoredGraph hat " + getNodeColor() + " Knoten!";
		}
	}

	static class EdgeColoredGraph<T extends Graph> extends Graph {
		private String color;

		public EdgeColoredGraph(String color) {
			this.color = color;
		}

		public String getEdgeColor() {
			return color;
		}

		public void setEdgeColor(String color) {
			this.color = color;
		}

		@Override
		public String toString() {
			return "Der EdgeColoredGraph hat " + getEdgeColor() + " Kanten!";
		}
	}
}

In der Main Methode erstelle ich mir jetzt einen Node- und EdgeColoredGraphen:

NodeColoredGraph<EdgeColoredGraph<Graph>> NECG = new NodeColoredGraph<EdgeColoredGraph<Graph>>("gruene");

Ist es irgendwie möglich, dass ich bei solch einem Graphen irgendwie Knoten UND Kanten eine Farbe zuweisen kann? Bisher kann ich ja nur dadurch dem NodeColoredGraph eine Farbe zuweisen...
Kann mir da wer weiterhelfen? ;-)

 

[Barista]

Bei Generics geht es oft um Behälter(Container).

Du musst also verstehen/durchdenken/ausformulieren,
was der Behälter ist und in welchem Masse die
enthaltenen Elemente eingeschränkt werden sollen.

Etwas anderes ist es bei typen wie Comparable.

public interface Comparable<T> {
public int compareTo(T o);
}


Dabei geht es um die Einschränkung des Parameters
der compareTo-Methode.

public final class Byte
implements Comparable<Byte> {...

Die Implementierung mit der Klasse selbst als
Typ-Argument sorgt dafür, dass ein Byte nur
mit einem Byte verglichen werden kann.