Funktion unabhängig vom Namen aufrufen

[KartoffelKiffer]

Hallo,

meine Frage beruht auf folgender Basis: Ich habe eine Klasse, in der einige Dateioperationen vonstatten gehen. Diese Dateioperationen werden ebenfalls in mehreren anderen Klassen und Funktionen aufgerufen.

Jetzt ist es lästig, wenn ich eine neue Dateioperation einfüge, in jeder Funktion, wo diese ebenfalls benötigt wird, diese Dateioperation manuell hinzuzufügen. Die Dateioperationen benötigen keinerlei Übergabeparameter, es sind alles void-Methoden.

Ist es nun möglich, dass wenn ich auf diese Dateioperationen zugreifen möchte, eine Funktion erstelle:
" Analysiere Klasse 'Dateioperationen' "
" Hole alle Methoden die wiefolgt lauten: präfix_Name() "
" Rufe alle Methoden auf, die dem Muster entsprechen "

So muss ich an der Stelle, wo die Dateioperationen allesamt aufgerufen werden müssen, nur noch die eine Funktion 'starteAlleDateioperationen' (wie oben beschrieben) aufrufen, und die gesamte Routine wird abgehandelt.

Das wars eigentlich schon. Ich hoffe mir kann geholfen werden.




Mfg Tom

 

[SlaterB]

warum erstellst du dir in 'Dateioperationen' nicht eine Hilfsoperation 'starteAlleDateioperationen'
mit einem einzelnen manuellen Einfügen einer neuen Operation und x-maligen einfachen Aufruf,
statt sich x-mal zu verrenken?

das Verrenken geht auch einigermaßem mit Reflection (suche danach bei google/ in Lehrbüchern)
mit Programmieren hat das aber wenig zu tun, damit machst du dein Programm undurchschaubar

 

[KartoffelKiffer]

Hallo Slater,

kurz und knapp: Klingt logisch. Ich erspare mir weitere Verrenkungen mittels Reflections oder ähnlichem und mache es so wie vorgeschlagen.

Ich danke Dir.

 

[SlaterB]

ach, Reflection wolltest du ja auch schon in eine einzelne Operation auslagern und dann mehrmals benutzen,
immerhin, das wäre schon mal was,

dann verstehe ich nicht ganz, wieso du nun so leicht doch zum Einfügen überschwenkst,
ich beglückwünsche dich aber zu dieser Entscheidung

 

[KartoffelKiffer]

Hallo,

genau, die Reflection in eine eigene Operation auslagern, die mir die Klasse X ausliest und darin enthaltene Methoden aufruft. Diese Reflection-Methode wollte ich dann lediglich mehrmals benutzen.



Mfg Tom

 

[KartoffelKiffer]

Hallo,

ich war doch unartig und habe mich an die Reflections gewagt. Mit Erfolg muss ich feststellen:

Reflect.java
---------------------------
import java.lang.reflect.Method;
import java.io.File;

public class Reflect extends Thread {

	private Object o = null;
	private File f = null;
	
	public Reflect(Object o, File f) {
		
		this.o = o;
		this.f = f;
	}
	
	public void run() {
		
		Class<?> c = (Class<?>)this.o.getClass();
		Method[] theMethods = c.getMethods();
		
		for (int i = 0; i < theMethods.length; i++) {
			
			String methodName = theMethods[i].getName();			
			if (methodName.startsWith("__")) {
			
				try {
					c.newInstance();
					c.getMethod(methodName, File.class).invoke(o, this.f);
				} catch (Exception e) {
					
					System.out.println(e.toString());
				}
			}
		}
	}
}

EineKlasse.java
---------------------------
new Reflect(this, files[i]).start();

Was passiert? Es werden alle Methoden der Klasse this mit dem Präfix __ aufgerufen und ein File-Objekt wird an die jeweilige Methode übergeben. Das ist natürlich noch etwas simpel, aber in meinem Falle ausreichend.

Wobei noch an den Konstruktor der Reflect-Klasse die Klasse übergeben werden muss, die reflektiert werden soll. In meinem Falle ist es die Instanz der lokalen Klasse this, aus der ich auch den Aufruf starte, Soll es eine andere sein, so übergibt man anstelle this zB 'new de.test.KlasseSache.MeineKlasse()'.

Ich hoffe auch aussenstehenden noch geholfen zu haben.

Gibts an meinem Code noch etwas zu meckern?



Mfg Tom