Generics mit Array funzt net ;(

[verzweifelter42]

uff..ich sitze schon den halben tag dran und weiß bei dem problem nicht mehr weiter! warum klappt das generic nicht mir arrays ? gibts da sonderformen?
hier mein code:


class Array<T>
{
T[] a = new T [10];

T get(int i)
{
return a;
}



}

public class Test
{
public static void main(String[] args)
{
Array<int> a = new Array<int>();

a.get(1);

}
}



Danke im Vorraus

 

[verzweifelter23]

hier nochmal etwas besser hingeschrieben

class Array<T>
{
       T[] a = new T [10];

        T get(int i)
        {
               return a[i];
         }
}

public class Test
{
         public static void main(String[] args)
         {
              Array<int> a = new Array<int>();

               a.get(1);

           }   
}

 

[Waldbeere]

Hi,

wenn Du Objekte erstellen willst, brauchst Du auch ne konkrete Klasse dafür.
In dem Fall den Du hast musst Du einfach von Object auf T casten.

T[] a = (T[])new Object[10];

Und bei der Initialisierung in der main-Methode musst Du als Typ Objekte übergeben.

Also aus:

Array<int> a = new Array<int>();

wird

Array<Integer> a = new Array<Integer>();

 

[verzweifelter23]

hallo leute! hab schon wieder ein problem mit generics:

public class Array<T>
{
	public T []ar =(T[]) new Object[10];
	
	public void add(T zeichen)
	{
		ar[0]= zeichen;
		
	}
	



	public static void main(String[] args)
	{
		
		Array<Integer> k = new Array<Integer>();
	
		k.add(2);

		Out.println(k.ar[0]);
          }
}

hier erscheint keine Ausgabe auf der Konsole( es müsste die zahl 2 ausgegeben werden!) und es kommt immer wieder zur folgenden fehlermeldung:
exception in thread " main" java.lang.ClassCastException:[Ljava.lang.Object; ar Array.main


was habe ich nur Falsch gemacht ;([/code]

 

[Waldbeere]

Ich weiss nicht genau warum das passiert, aber verhindern kannst Du das indem Du einen
getter dafür nimmst. Du solltest sowieso auf Variablen nur über Methoden zugreifen. Daher
mach die Methode private und schreib einen getter, sowie da unten, dafür.

public class Array<T> {
    
    private T[] ar = (T[]) new Object[10];

    public void add(T zeichen) {
        ar[0] = zeichen;

    }
    
    public T getValue() {
        return ar[0];
    }

    public static void main(String[] args) {

        Array<Integer> k = new Array<Integer>();

        k.add(2);

        System.out.println(k.getValue());
    }
}

Schau Dir mal Listen an, die sind angenehmer und eleganter als Arrays.

 

[Marco13]

Die Gründe dafür kann man hier nachlesen ...
http://www.angelikalanger.com/Gener...ncrete instantiation of a parameterized type?
es geht da die Typsicherheit verloren ... ist ein bißchen kompliziert.

Abhilfen... Stehen u.a. hier http://www.angelikalanger.com/Articles/JavaSpektrum/34.GenericCreation/34.GenericCreation.html

Eine davon wäre in diesem Fall vielleicht sowas wie

public class Array<T>
{
   public T []ar;


   public Array(Class<T> containedClass)
   {
       ar = (T[]) java.lang.reflect.Array.newInstance(containedClass, 10);
   }
   public void add(T zeichen)
   {
      ar[0]= zeichen;
   }

   public static void main(String[] args)
   {

      Array<Integer> k = new Array<Integer>(Integer.class);

      k.add(2);

      System.out.println(k.ar[0]);
   }
}

Aber trotz allem sollte 'ar' private sein, wie es Waldbeere schon gesagt hat!

 

[Beni]

Nimm doch einfach einen Object-Array anstelle des T-Arrays, und caste in einer "T get( int index )"-Methode auf T. So macht das auch die ArrayList in der Standard-Library.

 

[Marco13]

... und Waldbeere :wink:

 

[Beni]

Ne, ich meine nicht was Waldbeere macht.
Ich meine sowas:

private Object[] data = ...

public T get( int index ){
  return (T)data[ index ];
}

public void set( int index, T value ){
  data[ index ] = value;
}

Der andere Vorschlag ist gefährlich wie dieses Beispiel zeigt:

class Array<T>{
  private T[] data = (T[])new Object[ 5 ];
  public T[] getAll(){
    return data;
  }
}

Array<String> string = new Array<String>();

// hier gibt es keinen Compilerfehler...
String[] data = string.getAll();
// ... aber zur Laufzeit explodiert es hier

 

[Marco13]

Hm.... ???:L nagel' mich darauf jetzt nicht fest, aber....

class Foo<T>
{
    private Object[] data = new Object[5];

    public T get( int index )
    {
      return (T)data[ index ];
    } 
}

und

class Bar<T>
{
    private T[] ar = (T[]) new Object[10];

    public T get(int index) 
    {
        return ar[index];
    } 
}

sind glaubich in bezug auf die get-Methode äquivalent - d.h. bei der zweiten wird auch nur (vom Compiler) ein cast vor dem return IN (!) der get-Methode eingesetzt. Aber.... da müßte man sich vielleicht mal den bytecode ansehen...

 

[Beni]

Denke auch, dass die beiden dasselbe ergeben. Aber darum ging es mir nicht, nur dass ein "T[] new Object[10]" potentiell mehr Schaden anrichten kann sollte man jemals direkt mit dem Array arbeiten wollen.

 

[Waldbeere]

Jo ganz interesannter Beitrag Marco, habs aber nur überflogen

 

[Marco13]

Ja, das stimmt schon - außer wenn man es mit Arrays.newInstance erzeugt (wie es auch bei ArrayList#toArray(T[]) gemacht wird), aber das ist ja u.U. hier nicht erwünscht...