Generic Methode: syntax klemmt

[Souljumper]

hi,

ich hab mir aus dem Bereich Multithreading ein kleine Blockingqueue geschrieben wo ich jetzt aus Übungsgründen versucht hab generics reinzubringen.

Ich wollte aussagen, das der Parameter bei der Methode add() entweder der über <T> spezifierte Wert sein muss oder ein Wert, der von Number erbt. Ich krieg das syntaktisch aber nicht richtig auf die Reihe. Es gibt andauernd Fehlermeldungen er können den Typ nicht auswerten. Was mach ich da falsch ?

public class BQ<T> 
{
	private ArrayList<T> al;
	
	public BQ ()
	{
		al = new ArrayList<T>();
	}
	
	public synchronized void add(<? extends Number> m)
	{
		if (m == null)
			throw new NullPointerException();
		
		al.add((T) m);
		this.notifyAll();
	}
	
	public synchronized T get() throws InterruptedException
	{
		while(al.isEmpty())
			wait();
		
		T m =   al.get(0);
		al.remove(0);
		return m;
	}
}

 

[The_S]

[HIGHLIGHT="Java"] public synchronized <M extends Number> void add(M m)
{
if (m == null)
throw new NullPointerException();

al.add((T) m);
this.notifyAll();
}[/HIGHLIGHT]

siehe Java Blog Buch : 06.02 Generics

 

[Der Müde Joe]

sollte aber besser so sein (und in der Methode schlicht T)

public class BQ<T extends Number> {...

EDIT:
>entweder der über <T> spezifierte Wert sein muss oder ein Wert, der von Number erbt

eines von beiden, beides geht nicht. (nur mit viel Glück, sonst endets in einer ClassCastException)

 

[The_S]

sollte aber besser so sein (und in der Methode schlicht T)

public class BQ<T extends Number> {...

Wenn du meinst, mir war die Fragestellung etwas zu verwirrend um "weiterzudenken" .

 

[Souljumper]

danke soweit. ich hab derzeit immernoch probleme zu verstehen was generics können und was nicht.

hier ein weiterer versuch. ich hab versucht über <T extends Number> auszusagen das es sich um nummerische werte handeln muss. kann java dann auf basis des number-types additionen ausführen? scheinbar harkt das ganze jetzt an der stelle, dass der typ number immernoch zu wage ist.

das grobe konzept der generics hab ich zwar verstanden, aber wo da die leistungsgrenzen in der anwendung sind in verbindung mit wildcards und ober/unterbegrenzung der typen ist mir doch sehr schleierhaft.

public class T_game<T extends Number>
{
	public T addiere(T  a, T b)
	{
		return a+b;	
	}
	
	public static void main(String [] args)
	{
		T_game<Integer> tg = new T_game<Integer>();
		
		System.out.println("Ergebnis: " + tg.addiere(3, 2));
	}
}

 

[Illuvatar]

Naja... zwei Number-Objekte per +-Zeichen addieren ging noch nie, deshalb geht das jetzt auch nicht plötzlich magischerweise per Generics. Bis auf die String-Klasse gibts um genau zu sein gar keine Operator-Überladung.

Hier kannst du schauen, was du mit deinen Number-Objekten machen kannst. Addieren ist nicht dabei, aber z.B. in double konvertieren und dann addieren.

 

[SlaterB]

a+b ist sowieso nur für primitive Datentypen gedacht + evtl. AutoBoxing,
das solltest du hier nicht in einem Schlag mit Generics durchmischen

sachlich gesprochen stehen dir innerhalb von addiere genau die Methoden von a und b zur Verfügung,
die das Number-Interface anbietet,
z.B.
int x = a.intValue() + b.intValue();
wobei a auch ein Double mit Wert 10^230 sein kann, oder wie hoch das auch immer geht

ein neues T kannst du aber nicht erzeugen,
eine allgemeine Methode 'Number add(Number other)' existiert im Number-Interface schlicht nicht,
und selbst wenn muss man schon ganz schön tricksen, damit der Rückgabewert dann T ist und nicht einfach nur Number

class T_game<T extends CoolNumber<T>>
{
    public T addiere(T a, T b)
    {
        return a.add(b);
    }
 
 
}
 
 
class CoolInteger
    implements CoolNumber<CoolInteger>
{
 
    public CoolInteger add(CoolNumber<CoolInteger> other)
    {
        return null;
    }
 
}
 
 
interface CoolNumber<T>
{
 
    T add(CoolNumber<T> other);
}

edit: oder
[HIGHLIGHT="Java"]class CoolInteger implements CoolNumber<CoolInteger>
{
public CoolInteger add(CoolInteger other) {
return null;
}
}


interface CoolNumber<T> {
T add(T other);
}[/HIGHLIGHT]
(Code einfügen im Edit-Modus ist wohl nicht so gut..)

 

[maki]

>> ein neues T kannst du aber nicht erzeugen,

Ausser man verwendet einen "hässlichen" Trick.

 

[Ebenius]

(Code einfügen im Edit-Modus ist wohl nicht so gut..)

Hab den Code oben mal repariert. Wenn Du den Standard-Editor benutzt und nicht den WYSIWYG-Editor, dann ist das Einfügen auch kein Problem. Und die HIGHLIGHT-Tags sehen mit Java hübscher aus als CODE-Tags.

Ebenius

 

[Souljumper]

danke soweit.

hier nochmal so ein Beispiel

public class Methode<D> 
{
	public static <T extends Object> T nix(T x)
	{
		return x;
	}
	
	public <D> D nix_2(D x)
	{
		Integer i = (Integer) x/2;
		
		return (D) i;
	}

	public static void main(String [] args)
	{
		System.out.println(Methode.nix(3));
		Methode<Double> m = new Methode<Double>();
		System.out.println(m.nix_2(23));
	}
}

Wenn ich den bei der Klasse definierten Typwert weiter einschränken will, muss ich da zwangsläufig den Wert "<D>" benutzen? Ich erinnere mich an Codebeispiele wo auch in der Parameterliste be den Typen das extends bzw. super Codewort verwendet wurde. Wenn ich versuche in der Parameterliste zusätzliche Begrenzungen aufzunehmen meckert mir Eclipse das allerdings an.

Wann bzw. wo und wie kann ich bei den typen in der Parameterliste weitere Einschränkungen angeben mit den extends/super codewörtern?

 

[SlaterB]

es wurden doch weiter oben schon Beispiele genannt..,
<T extends Object> hast du sogar selber im Code,

die Einschränkung muss beim ersten Auftauchen eines generischen Typs angegeben werden,
für D also in der ersten Zeile, nicht später bei den Methoden,

das <D> in
> public <D> D nix_2(D x)
kann dann auch weg, D ist hier bereits definiert