# Javabefehl im String speichern.



## LosLegator (25. Februar 2008)

Hallo,

ich habe folgendes Problem.

Ich habe ein 

```
String[][] New= { {"1", "xyz", "new funktion();"},
{"2", "xyz", "new test();"},
{"3", "xyz", "new opener();"} 
};
```

Im letzen Eintrag ist eine Anweisung gespeichert.
Nun meine Frage - gibt es eine möglichkeit diese zu parsen, das sie von Java umgesetzt werden kann ?
Ähnlich wie Integer.parseInt(New[0][0].trim()); wo ja aus dem String ein Integer gemacht wird.

Schon mal Danke für die Hilfe.
MFG Legator


----------



## Romsl (26. Februar 2008)

So direkt wie du das vor hast wird das nicht gehen. Mittels Reflection ist das aber sicherlich möglich. Damit kannst du zur Laufzeit neue Instanzen von Klassen erzeugen, Methoden aufrufen, Felder ändern.

Schau mal hier:

http://www.galileocomputing.de/openbook/java2/kap_13.htm

Gruß,
  -- Romsl


----------



## LosLegator (26. Februar 2008)

Hi, Danke erstmal.

Ich werds mal versuchen da durchzusteigen.

Wenn jemand noch andere Vorschläge oder Anregungen hat, bin ich immer offen.

Legator


----------



## procurve (26. Februar 2008)

Abhängig von der Variabilität deiner "Befehle" könntest du auch eine einfache If-Konstruktion verwenden:


```
public Object parseSomething(String s) {
  if (s.equals("new funktion();")) {
    return new funktion();
  } else if (s.euqals("new test();")) {
    return new test();
  } ...
  
  // Falls keine der vorherigen Bedingungen zutrifft
  return null;
}
```

Bietet sich dann an, wenn du relativ wenige Auswahlmöglichkeiten für deine "JAVA-Befehle" im 3. String vorgegeben hast.


----------



## Klein0r (26. Februar 2008)

LosLegator hat gesagt.:


> Hi, Danke erstmal.
> 
> Ich werds mal versuchen da durchzusteigen.
> 
> ...



Also du versuchst in deinem Sourcecode eine Objektreferenz in ein Stringarray zu speichern. Das geht natürlich nicht.

Du könntest dir genauso gut eine Klasse Schreiben die alle 3 Werte speichert. Vllt beschreibst du einfach mal was du mit den Objekten da hinten machen willst bzw in wiefern die sich unterscheiden. Falls das ganze relativ ähnlich ist könntest du einfach ein Interface in alle 3 Klassen einbinden und so immer die selbe funktion aufrufen.

Beispiel:

*Das Interface das alle Klassen einbinden die du speichern willst:*

```
public interface Funktion {
	public void machwas();
}
```

*Die Klasse die später für die Collection genutzt wird:*

```
public class ArrayInfos {

	int id;
	String bezeichner;
	Funktion funct;
	
	public ArrayInfos(int id, String bezeichner, Funktion funkt) {
		this.id = id;
		this.bezeichner = bezeichner;
		this.funct = funkt;
	}

	public int getId() {
		return id;
	}

	public String getBezeichner() {
		return bezeichner;
	}

	public void ausfuehren() {
		this.funct.machwas();
	}
}
```

Deine Klassen die du nun alle in dein Array speichern willst müssen nurnoch das Interface Funktion implementieren.

*Beispielklasse:*

```
public class BeispielKlasse1 implements Funktion {

	private String test = "hallo ich bin ein Objekt der Klasse 1";
	
	public void machwas() {
		System.out.println(test);
	}

}
```

*Und noch eine andere Beispielklasse die was komplett anderes macht:*

```
public class BeispielKlasse2 implements Funktion {
		
	public void machwas() {
		for (int i=0;i<10;i++) {
			System.out.print("#");
		}
		System.out.println();
	}
}
```

*Nun kannst du endlich dein Array erstellen:*

```
ArrayList<ArrayInfos> meinArray = new ArrayList<ArrayInfos>();

meinArray.add(new ArrayInfos(1,"xyz", new BeispielKlasse1()));
meinArray.add(new ArrayInfos(2,"abc", new BeispielKlasse2()));
```

*Wenn du nun alle Funktionen ausführen willst die dahinter stehen machst du einfach:*

```
for (ArrayInfos ai : meinArray) {
	System.out.println("ID: " + ai.getId());
	System.out.println("Bezeichner: " + ai.getBezeichner());
	ai.ausfuehren();
	System.out.println("---------------------------");
}
```

*Ergebnis:*

```
ID: 1
Bezeichner: xyz
hallo ich bin ein Objekt der Klasse 1
---------------------------
ID: 2
Bezeichner: abc
##########
---------------------------
```

Das ganze nennt sich http://de.wikipedia.org/wiki/Polymorphie_(Programmierung) und kommt eigentlich recht häufig zum einsatz. Man weiß also nicht welche Funktion man aufrufen wird - bzw welcher Inhalt ausgeführt wird. Theoretisch könnte dort alles passieren.

Hoffe das war verständlich.


----------

