Zwei Comparable (compareTo) vergleichen

[Swoop]

Hallo,
mein Problem ist folgendes:
Ich möchte gerne eine Methode erstellen, welches eine Eigenschaft und einen Parameter vergleicht. Und dann ein Wert für eine Farbe zurückt gibt. Dazu habe ich folgende Klasse erstellt:

(gekürzt)

public class PD_VCellColor<C>
{
	private C value;

	private String color;

	private String doGreater(C value)
	{
		String color = null;
		int compare = this.value.compareTo(value);
		if (compare > 0)
			color = this.color;
		return color;
	}
}

Aufgerufen soll das ganze dann so werden:

public void addInRangeColor(Comparable<?> start, Comparable<?> end, String color)
{
		this.intervalValues.add(new PD_VCellColor<?>(start, end, color));
}

Mein Problem ist, dass es überhaupt nicht funktioniert. Im oberen Code wirft er einen Fehler (The method compareTo(capture#2-of ?) in the type Comparable<capture#2-of ?> is not applicable for the arguments (C)) und im unteren Beispiel will es nicht gehen aufgrund den <?> im Code. Allerdings möchte ich dem Nutzer jede Möglichkeit offen lassen, eine Klasse einzufügen, welche von Comparable abgeleitet ist.
Hat jemand vllt eine Lösung?

Grüße Swoop

 

[AngryDeveloper]

Damit du compareTo() auf C aufrufen kannst, muss C auch etwas implementieren, was die Methode compareTo definiert.

public class PD_VCellColor<C extends Comparable>
{
	private C value;

	private String color;

	private String doGreater(C value)
	{
		String color = null;
		int compare = this.value.compareTo(value);
		if (compare > 0)
			color = this.color;
		return color;
	}
}

Den zweite Code kann ich noch nicht so ganz nachvollziehen.
Was genau soll der bezwecken?
Den Konstruktor gibt es ja da auch noch nicht in dem Fall.

 

[Swoop]

Damit du compareTo() auf C aufrufen kannst, muss C auch etwas implementieren, was die Methode compareTo definiert.

Ich will es dem Nutzer von meiner Methode ja völlig offen lassen, ob er ein Double rein steckt oder ein Integer, oder aber eine Klasse die er selbst gebaut hat und von Comparable ableitet.

Den zweite Code kann ich noch nicht so ganz nachvollziehen.
Was genau soll der bezwecken?
Den Konstruktor gibt es ja da auch noch nicht in dem Fall.

Mein zweiter Code ruft im Prinzip das ganze dann auf.

public void addInRangeColor(Comparable<?> value, String color)
{
        this.intervalValues.add(new PD_VCellColor<?>(value, color));
}

Hier hab ich ihn nochmals leicht angepasst, damit es vllt verständlicher wird. Es sollen bei dem Aufruf alle möglichkeiten für den Benutzer offen gehalten werden. Die eintzige Vorgabe soll sein, dass es von Comparable abgeleitet ist, damit dei CompareTo Methode implementiert wurde.
Das Beispiel soll die Verlgeiche gespeichert werden und später mehrfach aufgerufen werden.

 

[AngryDeveloper]

Ich will es dem Nutzer von meiner Methode ja völlig offen lassen, ob er ein Double rein steckt oder ein Integer, oder aber eine Klasse die er selbst gebaut hat und von Comparable ableitet.

public class PD_VCellColor<C extends Comparable<?>>

Double und Integer implementieren ja auch Comparable.

[OT]Offtopic, weil ich glaube, dass das gar nicht ist was du möchtest:
Wenn wirklich alles rein kann (egal ob Comparable oder nicht), dann kannst du darauf aber auch kein compareTo() aufrufen.
Dann müsstest du da eher einen Umweg über Comparator machen: Comparator (Java Platform SE 6)

public class PD_VCellColor<C>
{
	private C value;
	private Comparator<C> comparator;
	private String color;

	private String doGreater(C value)
	{
		String color = null;
		int compare = comparator.compare(this.value, value);
		if (compare > 0)
			color = this.color;
		return color;
	}
}

[/OT]

Jetzt bin ich wieder bei Punkt 2:
Bin da jetzt durchaus ein wenig verwirrt. Denn wenn die Vorgabe "Comparable implementiert" lautet, warum dann nicht einfach in etwa:

public class PD_VCellColor
{
	private Comparable<?> value;
	private String color;

       //insert awesome constructor

	private String doGreater(Comparable<?> value)
	{
		String color = null;
		int compare = this.value.compare(value);
		if (compare > 0)
			color = this.color;
		return color;
	}
}

Und in Code 2:

public void addInRangeColor(Comparable<?> value, String color)
{
		this.intervalValues.add(new PD_VCellColor(value, color));
}

Wird dann nur Problematisch mit den ganzen ? bei den Generics, wenn du dann mal Klasse Auto mit Klasse Baum vergleichst und das Auto dann im Baum landet. :autsch:

 

[SlaterB]

verwende eine statische Methode zur Erzeugung

class PD_VCellColor<C extends Comparable<C>>
{
    private C value;

    private String color;

    public PD_VCellColor(Comparable<C> start, Comparable<C> end, String color2)
    {
    }

    private String doGreater(C value)
    {
        String color = null;
        int compare = this.value.compareTo(value);
        if (compare > 0) color = this.color;
        return color;
    }
    
    public static <T extends Comparable<T>>void create(Comparable<T> start, Comparable<T> end, String color)
    {
        new PD_VCellColor<T>(start, end, color);
    }
}

beim nicht-statischen add() geht das vielleicht auch, aber da sehe ich es kritisch, mehrere Methoden mit so freien Parameter vertragen sich glaube ich nicht, bzw. ein normaler Klassenparameter,
vielleicht aus Java 1.5 Zeiten nicht mehr aktuell

 

[Swoop]

Double und Integer implementieren ja auch Comparable.

Jetzt bin ich wieder bei Punkt 2:
Bin da jetzt durchaus ein wenig verwirrt.

Naja also nochmal:
Ich möchte dem Nutzer eine gewisse (große) Freiheit lassen. Allerdings müssen die Klassen von ihm auf jeden Fall von Comparable abgeleitet sein!

Wird dann nur Problematisch mit den ganzen ? bei den Generics, wenn du dann mal Klasse Auto mit Klasse Baum vergleichst und das Auto dann im Baum landet. :autsch:

Das war auch meine erste Idee. Allerdings motzt bei mir da der Compiler. Der Fehler ist im ersten Post zu sehen!
Ich könnte auch ein KSKB erstellen, wenn das weiterhelfen könnte!

beim nicht-statischen add() geht das vielleicht auch, aber da sehe ich es kritisch, mehrere Methoden mit so freien Parameter vertragen sich glaube ich nicht, bzw. ein normaler Klassenparameter,
vielleicht aus Java 1.5 Zeiten nicht mehr aktuell

Ändert das denn was an dem Problem mit den Generics ? oder ist das nur schöner Programmiert ? Denn der Code soll keineswegs so bleiben, nur ohne den nächsten Schritt mit Comparable und dem generischen brauch ich gar nicht fortfahren.

Gruß Swoop

 

[SlaterB]

> Ich könnte auch ein KSKB erstellen, wenn das weiterhelfen könnte!

in der Tat, wobei schon manche vorhanden sind,

Comparable<?> jedenfalls ist nutzlos, nichtmal

        Comparable<?> a = null;
        a.compareTo(a);

akzeptiert der Compiler..,
genausowenig können zwei Comparable<?> an die Klasse PD_VCellColor gehen,
es muss schon ein Konstrukt ähnlich meiner create()-Methode sein