Kann String in Befehl wandeln?

[fatfox]

Hallo alle,

ich möchte mal fragen, kann man die String in Befehl wandeln? ( ähnlich wie java für Datenbank SQL, man kann String Befehl schreiben, und execute( Befehl ) ) ???

z.B

public class StringBefehlTest {

	public static void Test(String classname) {

		classname abc = new classname(); // Die Zeile ist natürlich falsch.... :( 

	}

	public static void main(String[] args) {

		String classname = "Integer";
		Test(classname);

	}

}

Ist es überhaupt möglich, String Befehl auszuführen? Gibt es so eine ähnliche Funktion wie "execute( String Befehl) " in SQL ?

 

[Gonzo17]

Wofür brauchst du das?

Was auf jeden Fall funktioniert ist ein Methodenaufruf über einen String. klick

 

[XHelp]

Es ist schon möglich, aber wenn du sowas brauchst, liegt es meistens daran, dass du beim Design etwas falsch gemacht hast.
Wozu brauchst du es denn?

 

[DerEisteeTrinker]

Du willst also dynamisch Klassen laden, dann schau dir mal die Reflection an. Ansonsten wären vllt Generics noch etwas lesenswertes.

zum Verständnis:
Das execute beim SQL schickt ja nur deine Anfrage an die Datenbank. Die Datenbank wertet es dann aus bzw. versucht deine Anfrage zuverstehen.

 

[Tomate_Salat]

Soetwas kannst du mit Reflection erreichen. Wenn der String mehrere Befehle enthält, musst du ihn eben auseinander bauen. Aber ob das sinnvoll und notwendig ist, sei mal dahingestellt:

import java.lang.reflect.InvocationTargetException;


public class ReflectionDemo 
{
	public static void main(String[] args) 
	{
		try {
			ReflectionDemo.command("ReflectionDemo$CallMe someMethod");
			ReflectionDemo.command("ReflectionDemo otherMethod");
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
	
	void otherMethod() 
	{
		System.out.println("other Method was called");
	}
	
	static void command(String cmd) throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException 
	{
		String[] data = cmd.split(" ");
		
		Class<?> cl = Class.forName(data[0]);
		Object obj = cl.getDeclaredConstructor().newInstance();
		
		cl.getDeclaredMethod(data[1]).invoke(obj);
	}
	
	static class CallMe 
	{
		public void someMethod()
		{
			System.out.println("I was called");
		}
	}
}

 

[fatfox]

Danke alle! 😀

Ich habe nur zufällig darüber gedacht, ganz sinnvolle Anwendung habe ich bis jetzt noch nicht getroffen, 😀

aber ich denke, String Befehl umwandeln Methode ist sehr gemütlich zu benutzen. 😀

 

[DerEisteeTrinker]

Reflection ist das wohl mächtigste Feature von Java, denn ich kann auch private Elemente und Referenzen bearbeiten und damit die Anwendung mächtig überfordern. Grundsätzlich sollte man Reflection ur da einsetzen, wo es auch gebraucht wird

 

[nrg]

Du kannst auch eine ScriptEngine implementieren, dieser bestimmte Objekte übergeben und dann die Methoden der Klassen über die ScriptEngine ausführen.
z.B.

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class Util {
	
	public static void main(String[] args) throws ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		engine.put("util", new Util());
		engine.eval("util.doSomething()");
	}
	
	public void doSomething() {
		System.out.println("Hallo Welt");
	}
}

 

[Beni]

aber ich denke, String Befehl umwandeln Methode ist sehr gemütlich zu benutzen. 😀

Anstatt, dass der Compiler meckert und dein Programm nicht startet, fliegt dir jetzt irgendwann zur Laufzeit eine Exception um die Ohren weil der String falsch war... ich waere vorsichtig mit solchen Experimenten :shock:

(Edit: womit ich nicht sagen will, dass das alles nutzlos sei. Es gibt sicherlich Anwendungen für welche dies genau die richtige Lösung ist.)

 

[Tomate_Salat]

aber ich denke, String Befehl umwandeln Methode ist sehr gemütlich zu benutzen. 😀

bezweifel ich. Das mag vllt für Sonderfälle angenehm sein, aber i.d.R brauchst du Objekte, auf denen du arbeitest und natürlich auch Referenzen (ansonsten schlägt iwann der GC zu und du hast ein Problem!).

 

[Marco13]

Die Möglichkeiten sind vielfältig, und reichen von

class Dog
{
    public void bark() { System.out.println("miau"); }
}

über

class SomethingDoer
{
    public static Object doSomething(Object object, String action, Object ... arguments) {...}
}

bis

class God
{
    public static void letHappen(String what) { ...}
}

Man sollte genau überlegen, ob man mit dem Urfeuer spielen will 😡 😀

 

[Marco13]

(Ja, die letzte Klasse würden manche wohl schon aus Prinzip als Singleton implementieren :joke: )

 

[Tomate_Salat]

(Ja, die letzte Klasse würden manche wohl schon aus Prinzip als Singleton implementieren :joke: )

Ja, weil mich gibts nur einmal 😀