Generics Verständnisfrage

[Andi87]

Hallo,
ich befasse mich gerade ausführlicher mit Generics und kann folgendes einfach nicht verstehen:

Es gibt folgende Klasse:

public class StrangeClass<T> {
    
    private List<Integer> intList = new ArrayList<Integer>();
    
    public StrangeClass() {
        intList.add(8);
        intList.add(7);
    }
    
    public List<Integer> getIntList(){
        return intList;
    }

    public List<?> getSomeList(){
        return intList;
    }


}

und nehmen wir weiterhin an die Klasse hat noch Methoden usw. die mit dem Typ T arbeiten. Die intList und ihre Methode getIntList() haben also gar nichst mit dem Parameter T zu tun (sowie getSomeList() ).

Wenn ich nun StrangeClass also RawType instanziere versteh ich aber was nicht:

StrangeClass strange = new StrangeClass();
strange.getIntList().add("A String??");
strange.getSomeList().add("This is not null!");

Das funktioniert ohne Probleme! Wenn ich StrangeClass mit z.B. als StrangClass<String> instanziere geht das (wie man es erwarten würde) nicht mehr.

Kann mir das bitte jemand erklären!? Danke!

 

[foobar]

Deine Klasse ist völlig sinnfrei. Du deklariest zwar T nutzt es aber nirgends

public class StrangeClass<T> 
{
    
    private List<T> intList = new ArrayList<T>();
   
    public void add(T t)
    {
        intList.add(t);
    }
   
    public List<T> getIntList(){
        return intList;
    }

    public List<T> getSomeList(){
        return intList;
    }

    public static void main(String[] args)
    {
        StrangeClass<Integer> s = new StrangeClass<Integer>();
        s.add(8);
        s.add(9);
    }
}

 

[SlaterB]

ändert aber nichts an dem ursprünglichen Problem,

in einer <T>-Klasse, die ohne <T> verwendet wird, werden alle generischen Dinge gestrichen,
auch die, die gar nicht von T abhängen (z.B. fest List<Integer>),
worin liegt da der Sinn?

mag vielleicht technisch nicht anders zu machen sein, ist aber doch ganz schön übel,

noch ein Beispiel:

public class Test
{

    public static void main(String[] args)
    {
        B b = null;
        b.getIntegerList1().add("x"); // Fehler
        b.getIntegerList2().add("x"); // erlaubt, bis auf Warning 'raw type'
    }

}


class B<T>
    extends A
{

    public List<Integer> getIntegerList2()
    {
        return null;
    }

    public List<T> getTList()
    {
        return null;
    }
}


class A
{

    public List<Integer> getIntegerList1()
    {
        return null;
    }
}

 

[Marco13]

Wenn man einen "Raw type" verwendet (wie das ungetypte StrangeClass) dann führt der Compiler direkt eine Type Erasure durch, und die enthaltene Liste ist nichtmehr eine List<Integer>, sondern nurnoch eine List. Siehe auch http://www.angelikalanger.com/GenericsFAQ/FAQSections/TechnicalDetails.html#FAQ007

 

[Andi87]

Ja das war schon so beabsichtigt! Deswegen auch:

und nehmen wir weiterhin an die Klasse hat noch Methoden usw. die mit dem Typ T arbeiten. Die intList und ihre Methode getIntList() haben also gar nichst mit dem Parameter T zu tun (sowie getSomeList() ).

Deine Überarbeitung meiner Bsp-Klasse ist also nicht auf was ich hinaus will!

 

[Andi87]

Danke @Marco13! Das war es! Ich finds zwar immer noch seltsam, aber ich kann jetzt wenigstens nachvollziehen was passiert und wieso es nicht funktioniert.

 

[Marco13]

Hmja - WARUM genau das so IST, würde mich auch mal interessieren, aber dies "Type Erasure" ist vermutlich alles andere als trivial, und Raw Types eben eigentlich nicht mehr state of the art ... man muss es wohl zumindest akzeptieren...

 

[Andi87]

Naja... wenn ich den RawType einer generischen Klasse benutze wird eben dadurch garantiert dass die Klasse auch intern immer ohne Generics arbeitet. Eventuell um die kompatibilität zu älteren Versionen zu gewährleisten.... wo benutzt man sonst noch einen RawType (obwohl es eine generische Alternative gibt).