# Verschiedene Klassen mit for-Schleife aufrufen



## Pjuly (22. April 2013)

Hallo,

ich möchte in einer for schleife Methoden aus verschiedenen Klassen aufrufen und dabei eine Variable initalisieren. 


```
int[] groesse=new int[4];
for (int i=0;i<=3; i++){
        groesse[i]=KLASSE****?.getGroesse();
}
```

ich habe schon überlegt einen Array mit durchlaufen zu lassen mit den Klassennamen. Also:


```
int[] groesse=new int[4];
String[] dieKlassen={"erste", "zweite", "dritte", "vierte"}
for (int i=0;i<=3; i++){
        groesse[i]=dieKlassen[i].getGroesse();
}
```
Aber das funktioniert leider nicht... 

Ich hoffe es gibt eine geschickte Lösung für das Problem und vielen Dank für jede Antwort.

Liebe Grüße Pjuly


----------



## Pjuly (22. April 2013)

Schon 37 haben es gelesen, aber noch keine Antwort? 

habe jetzt schon einiges über HashMaps gelesen und glaube, dass es da evtl. auch eine Lösung gibt. 


```
HashMap<String, Class> map = new HashMap<String, Class>();
            map.put("0", erste.class);
            map.put("1", zweite.class);
            map.put("2", dritte.class);
            map.put("3", vierte.class);
```

Wie kann ich jetzt die Methode "getGroesse()", die in jeder der Klassen steht aufrufen?


----------



## Akeshihiro (22. April 2013)

Der Grund könnte darin liegen, dass vermutlich niemand so wirklich rafft, was du da eigentlich vor hast bzw. warum du so ein merkwürdiges Konstrukt brauchst. Was versuchst du da eigentlich zu bewerkstelligen?


----------



## hendl (22. April 2013)

Kommt ganz auf deine Verwendung an.
Wenn es dir genug ist das ein statischer Wert zurückgegeben wird musst du die Methode getGroesse() in der Klasse static sein.

```
public class erste{
public static int getGroesse(){
return 0;
}
}
```

Oder eine andere Möglichkeit wäre die Klassen dynamisch zu erzeugen. Und einer Oberklasse die, die Methode getGroesse() enthält und dann von jeder anderen Klasse überschrieben wird.

```
public class DAOFactory {
	public Oberklasse getClass(String klassenname){
		try {
			try {
				return (Oberklasse ) Class.forName(name).newInstance();
			} catch (InstantiationException | IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}

}
```


```
int[] groesse=new int[4];
String[] dieKlassen={"erste", "zweite", "dritte", "vierte"}
for (int i=0;i<=3; i++){
        Oberklasse help=new DAOFactory().getClass(dieKlassen[i]); 
        groesse[i]=help.getGroesse();
}
```


----------



## takidoso (8. Mai 2013)

Es gibt aber auch noch eine nette andere Art, in der man die Methoden, die alle Klassen gemein haben sollen in einem Interface definiert und die Klassen, die hier abgefragt werden sollen, dieses Interface implementieren lässt.
Das hat im Gegensatz einer unmitelbaren Vererbung den Vorteil, dass es auch Klassen sein können die Abstammungstecnisch nichts mit einander zu tun haben.


```
public interface GroesseHabend
{
    int getGroesse();
}
```


```
public class Erste implements GroesseHabend
   {
         public int getGroesse()
         {
              return 5;
         }
   }
```


```
public class Zweite implements GroesseHabend
   {
         public int getGroesse()
         {
              return 15;
         }
   }
```

...

```
public class MainStuff
   {
        static public GroesseHabend ghs[] =  new GroesseHabend [] {new Erste(), new Zweite(), new Dritte()};
        
       public static void  main(String[] args)
       {
           int gesamtGroesse = 0;
           for (GroesseHabend gh : ghs)
           {
                System.out.println(gh.getGroesse());
                gesamtGroesse += gh.getGroesse();
           }
           System.out.println(================);
           System.out.println(gesammtGroesse);
       }


   }
```

So oder so ähnlich (ich habe das jetzt nu rmal so getippt ohne es auszuprobieren, abe ich meine das müsste gehen.


----------

