Probleme mit Generics

[Meru]

Hallo,

ich habe eine generische Klasse (Call<T>), welche eine generische Liste enthält (fest definiert).
Wenn ich in einer anderen Klasse bin und ich die Klasse Call ohne den generischen Typ erzeuge, ist meine Liste, die ja innerhalb der Klasse Call fest generisch ist, auch ohne Typ.

Hier mal ein Beispiel:
Unten in dem Handler kann ich nicht auf den generischen Typ der Liste zugreifen. Warum kann ich das nicht? Der Typ ist doch fest definiert und unabhängig vom Typ T der Klasse Call?

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

interface DependencyValue{
	void setValue(Object o);
}

abstract class Call<T>{
	private List<DependencyValue> list = new ArrayList<DependencyValue>();
	
	protected T result;
	
	abstract public void call();
	
	public T getResult(){
		return this.result;
	}
	
	public List<DependencyValue> getDepCallValueList() { // fest definiert, also NICHT abhängig von Typ T
		return this.list;
	}
	
	/*
	 * und noch vieles, vieles mehr
	 */
}

class ConcreteCall extends Call<String>{ // nur der Vollständigkeit halber mit gepostet, trägt aber nicht zum Problem bei

	@Override
	public void call() {
		// super.result = rufe irgendetwas tolles auf
	}
	
	/*
	 * und noch vieles, vieles mehr
	 */
}

class Handler{
	private LinkedList<Call> callList = new LinkedList<Call>();
	
	void run(){
		Call call = callList.removeFirst();
		
		for (int i=0; i < call.getDepCallValueList().size(); i++){
			call.getDepCallValueList().get(i)./* warum gibt es hier nicht die Mehtode setValue? */;
		}

		// oder
		List<DependencyCallValues> blub = call.getDepCallValueList(); 
		// Type safety: The expression of type List needs unchecked conversion to conform to List<DependencyCallValues>
	}
}

Warum kann ich da nicht auf den konkreten Typ zugreifen? Mir erscheint das unlogisch.

Gebe ich Call aber den Typ T an, dann funktioniert es wunderbar.

class Handler{
	private LinkedList<Call> callList = new LinkedList<Call>();
	
	void run(){
		Call<String> call = callList.removeFirst(); // hier nun konkret der Typ T
		
		for (int i=0; i < call.getDepCallValueList().size(); i++){
			call.getDepCallValueList().get(i).setValue("blub"); // es geht ohne Probleme
		}

		// oder
		List<DependencyCallValues> blub = call.getDepCallValueList();  // es kommt kein Warning mehr
	}
}

Hab ich da einen Denkfehler? Muss bei einer generischen Klasse immer der Typ angegeben werden damit auch die innerhalb der Klasse defnierten "konkreten Listen" auch funktionieren?
Oder handelt es sich dabei eher um einen Java-Bug? Ich habe diesen Code in Eclipse wie auch Netbeans probiert. Bei beiden wurde es meiner Ansicht nach falsch angzeigt (wobei die ja auch nur die Compilerwarnung ausgegben).

Mit Sichherheit kann ich das ganze Zeug nachher casten, aber es geht hierbei eher um das Prinzip warum und wieso.

Hoffe man versteht was ich meine.

MfG

Meru

 

[Antoras]

Ich hab den Code mal ausprobiert und er funktioniert tatsächlich nicht.

Wenn du anstelle des RawTypes einen Wildcard benutzt compiliert der Code aber wieder.

Call<?> call = callList.removeFirst();

Ich kann dir aber nicht sagen ob das ein Bug in Zusammenhang mit RawTypes oder spezifiziertes Verhalten ist.

 

[faetzminator]

Das ist eine gute Frage kann ich mir auch nicht erklären... Vielleicht kennt sich da jemand besser mit der JVM aus als ich. Ist aber IMHO ein JVM Bug!?
Aber warum kennst du den Typen von [c]Call<T>[/c] nicht? Da du damit arbeiten musst, solltest du diesen eigentlich kennen.

Edit: Ansonsten würde [c]Call<?>[/c] auch funktionieren

 

[Meru]

An dieser Stelle kenn ich ihn nicht und er intesessiert mich an dieser Stelle auch nicht,

Ich habe nachher 10 Calls, alle haben einen unterschiedlichen Rückgabewert. Der Handler selber muss aber nicht wissen welchen, sondern nur den Call aufrufen und anschließend sagen, dass unser Result verteilt weden soll. Wie das gemacht werden soll und wohin er das verteilt, das entscheiden nachher Listener, die dem Call angehangen sind.


Jedenfalls danke für eure Einschätzung bzgl des komischen Verhaltens und für den <?>, wobei das aber nicht zur Verständlichkeit beiträt

 

[Marco13]

Ich denke, das entspricht dem, was unter AngelikaLanger.com - Java Generics FAQs - Under The Hood Of The Compiler - Angelika Langer Training/Consulting steht.

 

[Antoras]

Das Problem scheint bekannt zu sein, in der JLS hab ich dazu etwas gefunden:

For example,

    import java.util.*;

    class NonGeneric {

        Collection<Number> myNumbers(){return null;}
    }
    abstract class RawMembers<T> extends NonGeneric implements Collection<String> {
        static Collection<NonGeneric> cng = 
                                                                                    new ArrayList<NonGeneric>();

        public static void main(String[] args) {
                    RawMembers rw = null;
                    Collection<Number> cn = rw.myNumbers(); // ok
                    Iterator<String> is = rw.iterator(); // unchecked warning
                    Collection<NonGeneric> cnn = rw.cng; // ok - static member
        }
    }

RawMembers<T> inherits the method

    Iterator<String> iterator()

from the Collection<String> superinterface. However, the type RawMembers inherits iterator() from the erasure of its superinterface, which means that the return type of the member iterator() is the erasure of Iterator<<String>, Iterator. As a result, the attempt to assign to rw.iterator() requires an unchecked conversion (§5.1.9) from Iterator to Iterator<String>, causing an unchecked warning to be issued.

In contrast, the static member cng retains its full parameterized type even when accessed through a object of raw type (note that access to a static member through an instance is considered bad style and is to be discouraged). The member myNumbers is inherited from the NonGeneric (whose erasure is also NonGeneric) and so retains its full parameterized type.