Variabel: Nach String benannte Methode ausführen

[gurke123]

Hallo zusammen!

Ich habe eine grundlegende Frage; es jedoch etwas schwierig diese zu erläutern:
Ist es möglich in Java, Methoden über ihren Namen ausführen, der jedoch variabel sein kann, lediglich so heißt wie eine der Methoden?

Beispiel:

In der folgenden Methode soll über den übergegeben String überprüft werden, ob es eine Methode gibt, die so heißt, wie der übergebene String - dies jedoch ohne jede einzelne Methode über eine if-Anweisung abzufragen. Die Methode, die nach dem String benannt ist, soll ausgeführt werden.

public void fuehreMethodeAus(String methodenName) {

//...

}

Beispielmethoden:

public void methode1() {
//...
}

public void methode2() {
//...
}

public void methode3() {
//...
}

Und dies soll eben ohne If-Anweisung oder Ähnlichem geschehen?
Also nicht nach dem Schema:

if (methodenName.equals("methode1")) {
methode1();
}

Ich hoffe, ich habe mein Problem klar und deutlich dargelegt.
Gibt es dafür irgendeine Lösung?
Sollte mein Problem nicht deutlich geworden sein, werde ich mir Mühe geben, es noch einmal zu erklären.
Ich bedanke mich bereits im voraus für die Hilfe!
Viele Grüße!

 

[Thallius]

Ja ich verstehe was du meinst aber in 99% der Fälle ist deine Anforderung ein Zeichen von Unverständnis oder ein schlechtes Konzept oder einfach Unwissen. Nur in 1% der Fälle wird so etwas wirklich gebraucht. Ich habe das zum Beispiel in über 30 Jahren als Software Entwickler noch nie benötigt.

Also ist es vielleicht sinnvoll wenn du uns erklärst was für einen Prozess du damit abbilden willst. Dann können wir dir sagen ob das wirklich Sinn macht.

Gruss

Claus

 

[Androbin]

Also, wenn du keine if-Abfragen machen willst, dann
löse das ganze doch einfach mit einem Switch:

public void führeMethodeAus( String methodenName ) {
	
	switch ( methodenName ) {
		
		default:
			System.err.println( "Fehler: Nicht registrierte Methode: " + methodenName );
			break;
			
		case "Methode 1":
			methode1();
			break;
			
		case "Methode 2":
			methode2();
			break;
			
		case "Methode 3":
			methode3();
			break;
			
	}
	
}

 

[gurke123]

Seit ein paar Jahren arbeite ich nun inzwischen auch mit Java.
Ich brauche das oben angegebene Konzept in keinem genauen Fall, ich wüsste jedoch gerne wie man so etwas geschickt umsetzen würde.

Eine Switch-Anweisung kommt letztlich einem If-Statement gleich. Auch bei dieser müssen die möglichen Methodennamen ja bereits abgefragt werden.
Ich würde lediglich gerne wissen, wie man eine solche Methode aufrufen kann, ohne sie per if oder switch abzufragen.

Irgendwie sollte es ja funktionieren. Mir ist natürlich bewusst, dass es in 99,9% der Fälle niemals verwendet wird. Ich habe mir aber die Frage gestellt, wie man so etwas allgemein wohl lösen würde und bin auf keine Lösung gekommen.
Daher wollte ich mal bei erfahreneren Leuten nachfragen, insbesondere wenn sie dies seit 30 Jahren beruflich tun.

 

[lawila]

!!! ACHTUNG !!! von folgendem rate ich dringend ab ! es ist lediglich ein hinweis der machbarkeit und was intern so teilweise abläuft ... für einen produktiven einsatz sollte man folgendes nie anwenden da teilweise auch sicherheitskritisch !

eine weitere möglichkeit (und auch die eigentliche interne arbeitsweise von java) wäre noch reflection

man hat über reflection die möglichkeit sich "dynamisch" klassen und deren methoden zu laden und auch mit bestimmten parametern auszuführen ...

ein beispiel wäre in etwa das ich mir über einen class-loader eine externe klasse lade ... diese nach einem bestimmten suchmuster auslese und wenn ich was treffendes habe oder weis was ich von außen bewusst auslösen will kann ich dies auch tun ... das ist aber wie gesagt nur ein reines theoretikum was man mit reflection machen könnte ... teilweise läuft dies dann auch intern so ab (hat aber was damit zu tun das java eben so konzipiert wurde und bei der entwicklung der betroffenen klassen nicht genug über einen besseren umweg nachgedacht wurde sondern einfach brachial der direkte weg durch die mitte gewählt wurde)


@Thallius
ich kann dir EIN beispiel geben in dem man soetwas verwenden könnte ... auch wenn es trotzdem unsauber ist und es sicher einen besseren weg gibt : modularer programmaufbau und inter-modul-kommunikation

ich selbst habe mir aus grund des lernens ein kleines modul-system zusammen gesteckt und es auch soweit ausgebaut das sich zwei module direkt untereinander verständigen können

dabei kommt es zu dem problem : woher weis modul B welche methode ausgeführt werden soll wenn dies von modul A nicht gesagt wird ?

ich bin dann teilweise auf die wahnwitzige idee gekommen eine art callback-loop zu bauen (was mir auch das eine mal sowas von den ram zugemüllt hat das selbst das killen des java-prozesses sehr aufwändig wurde) so nach dem motto : a wirft b ein callback zu und b fragt über den callback nach was zu tun ist ...

schon mal völliger blödsinn


dann bin ich auf eine art protokoll gekommen und hab mir als relativ simples beispiel HTTP genommen

HTTP hat verschiedene methoden, darunter z.b. GET und POST die dem server sagen was nun überhaupt mit dem request zu machen ist

meine umsetzung : über eine "doIt()" methode die im interface spezifiziert war und einem "message"-objekt in einer festen struktur mitteilen : was mit welche daten von welchem modul auszuführen ist ...

war schon mal besser als der callback-loop ... aber immer noch nicht zufriedenstellend


an dem punkt hab ich das ganze dann aufgegeben und mir eine fertige lösung genommen


worauf ich hinauswill um es kurz zu machen : eine sinnvolle möglichkeit anhand eines parameters zu entscheiden welche sub-routine abläuft ist z.b. im datenfluss modularer systeme wenn ein modul nicht direkt auf ein anderes zugreifen kann sondern lediglich eine message auf einen event-bus legen kann der dann irgendwann bei korrekter kodierung vom gewünschten ziel-modul empfangen und ausgeführt wird


vielleicht hast du ja sogar noch einen tipp für mich wie ich das vielleicht besser umsetzen könnte
ich wollte dir nur einen möglichen einsatzzweck in form eines praktischen beispieles geben
das es zwar etwas von TO frage abweicht, nämlich dem "direkten ausführen einer methode anhand des namens" ist mir auch klar da dies so nur mit reflection möglic hist, aber wenn man es abstrakter sieht kommt man sehr schnell auf sehr viele beispiele wie anhand eines parameters gesteuert wird welche weitere sub-methode abläuft (um mal sowas wie factories gar nicht erst erwähnen zu wollen da es hier sogar soweit geht von welcher sub-klasse das erzeugte objekt ist)

 

[Thallius]

Der eigentlich Punkt ist doch, dass es keinen Sinn macht so ein Interface zu erstellen wo der Sender nicht weis was der Empfänger eigentlich kann und was nicht. Denn was willst du definieren als Ergebnis einer Methode die der Empfänger nicht kennt?

Der Sender muss also immer wissen was der Empfänger verarbeiten kann und was nicht. Und dafür gibt es jede Menge gängige Protokolle die man verwenden kann.

Gruss

Claus

 

[Ruzmanz]

Okey, das wird so nicht gemacht, weil es mit Interfaces/Klassen besser geht ... so wie ich das verstanden habe ist das ein simpler Command Pattern. Nur ein bisschen unlogisch

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;

public class EventHandler {
	Map<String, Command> methods = new HashMap<>();
	
	public void register(IReceivable receivable) {
		for(Method method: receivable.getMethods()) {
			methods.put(method.getName(), new Command(receivable, method));
		}
	}
	
	public void receivedMethod(String name) throws Exception {
		if(name == null || !methods.containsKey(name)) {
			throw new IllegalArgumentException("Pech gehabt...");
		}
		methods.get(name).execute();
	}
	
	private class Command {
		protected Object obj;
		protected Method method;
		
		public Command(Object obj, Method method) {
			this.obj = obj;
			this.method = method;
		}
		
		public void execute() throws Exception {
			method.invoke(obj);
		}
	}
}

import java.lang.reflect.Method;
import java.util.List;

public interface IReceivable {
	public List<Method> getMethods();
}

Habe es mal schnell runtergetippt. Keine Garantie auf Vollständigkeit. Parameter habe ich ausgelassen ... Ein "Testprogramm":

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class Tester {
	private static class ABC implements IReceivable {
		private String name;
		
		public ABC(String name) {
				this.name = name;
		}
		
		public void honululu() {
			System.out.println("ABC(" + name + "): Methode honululu() ausgeführt.");
		}
		
		public void total() {
			System.out.println("ABC(" + name + "): Methode total() ausgeführt.");
		}
		
		@Override
		public List<Method> getMethods() {
			List<Method> methods = new ArrayList<>();
			try {
				Class<?> c = Class.forName(this.getClass().getName());
				methods.add(c.getDeclaredMethod ("honululu"));
				methods.add(c.getDeclaredMethod ("total"));
			} catch (Exception nothing) {}
			
			return methods;
		}
	}
	
	private static class Oh implements IReceivable {	
		public void nein() {
			System.out.println("Oh nein");
		}
		
		@Override
		public List<Method> getMethods() {
			List<Method> methods = new ArrayList<>();
			try {
				Class<?> c = Class.forName(this.getClass().getName());
				methods.add(c.getDeclaredMethod ("nein"));
			} catch (Exception nothing) {}
			
			return methods;
		}
	}
	
	
	
	public static void main(String[] args) throws Exception {		
		EventHandler eventHandler = new EventHandler();
		
		eventHandler.register(new ABC("a"));
		eventHandler.register(new Oh());
		
		eventHandler.receivedMethod("honululu");
		eventHandler.receivedMethod("honululu");
		eventHandler.receivedMethod("nein");
		eventHandler.receivedMethod("total");
	}
}

PS: Ja am Code kann man noch optimieren ...

 

[dzim]

Das lustige ist, dass so einige Frameworks Reflection verwenden. Bsp. JAXB: wenn man dort eine bestimmte Methode einfügt (sorry, Name vergessen, weil völlig abstrus), dann kann man an Logging vom Un/Marshaller selbst kommen.

Ich musste Reflection vor kurzen auf Android nutzen (auch wenn es speziell hier vor allem eins ist: langsam): Es gibt eine alte und eine neue API wie man Netzwerk-Events (unabhängig von den Broadcasts) abfangen kann. In der neuen sind vor allem auch mittels sinnvoller API Netze wie LTE etc. bedacht. In der alten nicht ODER nur mit als intern markierten Methoden (teilweise sogar Herstellerabhängig), auf die man normalerweise nicht, oder eben nur mit Reflection kommt. Das ist voll bescheuert, aber wenn man viele Informationen zum Netz und seiner Qualität anzeigen möchte, gibt es jedenfalls so lange bis die API von Android 4.4 nicht verbreitet ist, keine andere Möglichkeit.

Auch manche Event-Listener-Frameworks arbeiten so - warum gibt es die so oft festen Strukturen von Gettern und Settern wohl?
Neuestes Beispiel: PropertyValueFactory aus JavaFX. Man gibt den Namen der Property an (also wie die Variable im Modell heisst) und es wird explizit nach "get<PropertyName>", set<PropertyName>" und "<propertyName>Property" gesucht. Fehlt die letzte Methode, wundern sich viele, die in JavaFX einsteigen, warum ihr Tabellen/Listen/... nicht aktualisiert werden.

Viele andere Frameworks setzen halt auf Annotation (und das ist auch gut so), aber manchmal wird eben noch immer auf diese Basics zurückgegriffen...

 

[lawila]

ich habe folgende antwort gestern schon mehrfach versucht zu verfassen, es letzten endes aber doch gelassen weil mir die formulierung nicht gepasst hat ... auf ein neues

ich hab mir mal vor langer zeit eher zum lernen und ausprobieren eine sehr simple modulare struktur geschrieben

haupt-kern des ganze ist natürlich ein interface : "Modul"
dieses interface definiert folgende methoden

void load(Handler)
void init()
void start()
void stop()
void destroy()
void unload()
Response reqeustResponse(Request)

ich denke anhand der gewählten namen sollte klar sein was wofür sie da sind

zusätzlich gibt es einen Loader und einen Handler
der Loader ist relativ einfach gestrickt : er läd die module und übergibt durch die load(Handler) methode eine instanz des Handlers

der Handler ist dann etwas komplexer aufgebaut
nicht nur das er für die verwaltung und ausführung zuständig ist, er ist auch das einzige bindeglied über das alle calls laufen

eigentlich recht banal : eine Map in der die modul-instanzen mit einem identifier (im einfachsten fall einfach ein name) gespeichert werden, eine List in der die registrierten EventListener gespeichert werden, eine Modul[] getModules() methode um sich alle module zu holen sowie entsprechende register/remove methoden für die listener und eine fireEvent() methode

für die kommunikation sind nun bei diesem konstrukt drei wege vorgesehen : passiv, event und direct

passiv sollte klar sein : es wird ein listener reagiert um auf events zu reagieren
event ist das gegenstück dazu : man feuert ein event um diese an registrierte listener zu schicken

direct : eigentlich etwas was mir persönlich widerstrebt aber durch aus nötig sein kann
man holt sich über die getModules() methode ein array der modul-instanzen und kann so direkt auf das modul-objekt zugreifen

hierbei gibt es dann natürlich die möglichkeit zu casten und die gewünschte methode direkt zu callen (was statisches linken während der entwicklung erfordert)


die andere möglichkeit, und das ist in etwa das worum es hier geht, ist der punkt das in einem event die information enthalten ist welcher listener reagieren soll, welche aktion dann vom ziel ausgeführt werden soll und die entsprechenden daten


was hat das mit TOs frage zu tun ?

nun, nehmen wir das grundbeispiel : modul A möchte mit modul B etwas machen, hat aber keine direkte referenz auf B und kennt die struktur von auch nicht (dem entwickler war also zur entwicklung die struktur von B nciht bekannt)
nun hat A nur die möglichkeit ein event auszulösen in dem halt eine information enthalten ist was zu tun ist

ob man dies nun in einem switch-case implementiert, oder mit refelctions spielt eigentlich keine rolle ... das ergebnis ist das gleiche : B muss anhand der infos aus dem event ermitteln was A nun will ohne das A eine direkte referenz auf B hat um die gewünschte methode direkt zu callen



@Thallius
warum würde so etwas keinen sinn machen ? ich bin gerne für einen vorschlag offen wie man es besser machen könnte
wobei, wenn ich mir so andere beispiele ansehe, gerade auch bekannte, wie sollte es sonst funktionieren ?

der sinn eines interfaces ist es die konkrete implementierung zu kapseln was zur folge hat das man bestimmte methoden der konkreten implementierung nicht nutzen kann


oder nehmen wir mal ein beispiel aus der SE-API : LinkedList

wenn ich korrekt die deklaration so schreibe : List<?> list=new LinkedList<?> ... ist es mir unmöglich auf konkrete methoden von LinkedList wie z.b. addFirst() oder addLast() zuzugreifen

baue ich mir aber einen warper "ListWarper" der dann eine methode hat wie "addSpecial()" kann ich den ersten parameter dafür verwenden anzugeben das ich z.b. "addLast()" callen möchte
eine mögliche implementierung wäre dann z.b. das halt mit reflections die methoden durchgegangen werden und gesucht wird ob eine gewünschte methode exisitiert
falls ja wird diese gecallt
falls nein wird als fallback einfach add() gecallt

es gibt nun mal nur drei möglichkeiten : propagieren, erfragen, ausprobieren

propagieren : ein modul / eine sub-implementierung gibt an was sie alles implementiert
erfragen : der handler erfragt welche methoden zur verfügung gestellt werden
ausprobieren : man übergibt einen identifiere der angibt was konkret auszuführen ist (sinnvoll natürlich eine wie beim List-beispiel angesprochene fallback-möglichkeit)


wenn du einen anderen ansatz hast bin ich wie gesagt gerne für eine erklärung offen

 

[Thallius]

@Thallius
warum würde so etwas keinen sinn machen ? ich bin gerne für einen vorschlag offen wie man es besser machen könnte
wobei, wenn ich mir so andere beispiele ansehe, gerade auch bekannte, wie sollte es sonst funktionieren ?

der sinn eines interfaces ist es die konkrete implementierung zu kapseln was zur folge hat das man bestimmte methoden der konkreten implementierung nicht nutzen kann


oder nehmen wir mal ein beispiel aus der SE-API : LinkedList

wenn ich korrekt die deklaration so schreibe : List<?> list=new LinkedList<?> ... ist es mir unmöglich auf konkrete methoden von LinkedList wie z.b. addFirst() oder addLast() zuzugreifen

baue ich mir aber einen warper "ListWarper" der dann eine methode hat wie "addSpecial()" kann ich den ersten parameter dafür verwenden anzugeben das ich z.b. "addLast()" callen möchte
eine mögliche implementierung wäre dann z.b. das halt mit reflections die methoden durchgegangen werden und gesucht wird ob eine gewünschte methode exisitiert
falls ja wird diese gecallt
falls nein wird als fallback einfach add() gecallt

es gibt nun mal nur drei möglichkeiten : propagieren, erfragen, ausprobieren

propagieren : ein modul / eine sub-implementierung gibt an was sie alles implementiert
erfragen : der handler erfragt welche methoden zur verfügung gestellt werden
ausprobieren : man übergibt einen identifiere der angibt was konkret auszuführen ist (sinnvoll natürlich eine wie beim List-beispiel angesprochene fallback-möglichkeit)


wenn du einen anderen ansatz hast bin ich wie gesagt gerne für eine erklärung offen

Gerade bei dem Beispiel erkenne ich den Sinn nicht. Du willst eine Methode addLast implementieren oder auch nicht. Wenn es addLast nicht gibt, willst du add aufrufen. Nun gibt es zwei Möglichkeiten:
1) addLast macht das gleiche wie add... Dann braucht es kein addLast
2) addLast macht was anderes als add und dann weiß der aufrufende Call doch gar nicht was jetzt eigentlich gemacht wurde? Also kann er doch auch gleich erst nachsehen ob addLast implementiert ist und wenn nicht, dann ruft er selber add auf und weiß dementsprechend auch was das Ergebnis ist.

Interfaces sind natürlich wichtig aber doch nur wenn diese vernünftig dokumentiert sind. Sprich wenn klar ist was der Empfänger kann und was nicht und ich dementsprechend damit arbeiten kann. Ein Try and error macht doch keinen Sinn. Das wäre ja als würde ich eine Methode int y=get4() aufrufen die mir eigentlich eine 4 zurückliefern soll, diese ist aber nicht implementiert also gibt sie mir einfach mal eine 3 zurück. Wie soll ich das als Caller denn dann managen?

Gruß

Claus

 

[Ruzmanz]

Ich musste Reflection vor kurzen auf Android nutzen (auch wenn es speziell hier vor allem eins ist: langsam): Es gibt eine alte und eine neue API wie man Netzwerk-Events (unabhängig von den Broadcasts) abfangen kann. In der neuen sind vor allem auch mittels sinnvoller API Netze wie LTE etc. bedacht. In der alten nicht ODER nur mit als intern markierten Methoden (teilweise sogar Herstellerabhängig), auf die man normalerweise nicht, oder eben nur mit Reflection kommt. Das ist voll bescheuert, aber wenn man viele Informationen zum Netz und seiner Qualität anzeigen möchte, gibt es jedenfalls so lange bis die API von Android 4.4 nicht verbreitet ist, keine andere Möglichkeit.

Genau dieses Problem hatte ich bei der Frage auch im Hinterkopf. Es gib X Module, die im Prinzip das selbe tun, aber anders ausgeführt werden müssen. Selbstverständlich kann man die Module aus tausend Gründen nicht ändern. I.d.R. reicht ein einfaches if-else aus. Für neue Module, sollte man aber ein Interface entwerfen:

public class Server {

  public void executeTask(Object obj) {
     if(obj instanceof PDFPrinter) {
       // pdfPrinter.setReady();
       // pdfPrinter.execute();
       // pdfPrinter.stop();
     } else if(obj instanceof CSVDump) {
       // csvDump.ausfuehren();
     }
     // ...
     else if(obj instanceof IExcecutable) {
       // obj.execute();
     }
  }
}

Man könnte das ganze "dynamischer" (mit Reflexions) machen, indem man die einzelnen Methodenaufrufe in einer Text-/XML-Datei ablegt. Sofern zu einem späteren Zeitpunkt noch mehr unveränderbare Module hinzugefügt werden müssen, ohne die Implementierung des Servers zu verändern. Ich möchte nochmals ausdrücklich hinweisen, dass dies nur aufgrund der beiden Eigenschaften "unveränderbare Module" und "anschließend unveränderbarer Server" notwendig ist. Das impliziert aber auch gleichzeitig, dass mit einer besseren Planung / Weitsicht dieses Problem gar nicht entstanden wäre!

wenn du einen anderen ansatz hast bin ich wie gesagt gerne für eine erklärung offen

Bei deinem Fall ist das ein Fehldesign. Wenn ich einen Service anbiete, dann habe ich absolut keine Ahnung wie die Module aussehen könnten, welche irgendjemand in der Zukunft entwirft. Es funktioniert trotzdem ... wenn deine Implementierung "Alles" können muss, dann musst du halt einen Just-In-Time-Interpreter zur Verfügung stellen. "Alles" erlauben und auf Sicherheit zu setzen läuft nicht.

 

[lawila]

hmm ... gut, ich gebe ja zu das mein code nicht das non-plus-ultra ist ... da ich ihn auch eigentlich nur für mich selbst geschrieben habe ...

... aber gucken wir uns doch mal z.b. OSGi bzw dessen implementierung in eclipse an
ich geb zu, ich hab davon null plan, aber was wird dort denn so sehr viel "besser" umgesetzt als bei meinem code ?

eclipse gibt über OSGi auch nur ein (bzw mehrere) interface vor nach dem dann die modul-klassen zu basteln sind

und dabei kann eclipse ach nicht alles vorgeben was möglich ist


und selbst wenn man das ganze runterbricht auf ein "Executable"-interface das dann nur eine methode "execute()" vorgibt, so scheitert es doch schon alleine an den parametern und den möglichen exceptions

die parameter bekommt man relativ einfach in den griff : Object[] ... einzige möglichkeit
bezüglich den exceptions, klar, man kann wild RuntimeExceptions schmeißen (wobei man exceptions ja eh grundsätzlich nie zur programmflusssteuerung nutzt !) ... man kann aber auch z.b. eine "ModulException" als checked Exception vorgeben in die dann alles rein muss ... also ggf auch unchecked RuntimeException

@Ruzmanz
das "I" als prä-fix für ein Interface ist in java un-üblich und wird eher im C-raum genutzt
in java hat sich folgende schreibweise etabliert

Executable - das Interface bekommt schlicht den namen was es darstellt
AbstractExecutable - eine abstrakte basis-klasse die grundlegende funktionen bereitstellt - ist kein muss, aber optional
ExecutableImpl - einer konkreten implementierung wird entweder "Impl" angehängt oder ein sprechender name gegeben was sie macht ... z.b. WinEXE oder UnixBinary ... wobei eine kombination eher unüblich ist, also z.b. nicht WinExecutableImpl ... weil das dann eher wieder die falsche annahme einer abstract oder eines interface mit dem namen WinExecutable auslösen könnte

das aber nur mal so nebenbei als rand-info


um mal wieder auf meinen code zurückzukommen

nehmen wir doch mal an das es keine "getAllModules()" geben würde, es so also wirklich KEINE möglichkeit gibt direkt an eine instanz des moduls zu kommen, sondern nur über den event-bus oder mit einem identifier

das problem bleibt das gleiche : wie bestimme ich das korrekte ziel-modul ?
habe ich keine möglichkeit mit instanceof zu prüfen da mir schlicht und einfach keine objekte vorliegen kann ich es nur über einen eindeutigen identifier machen der dann irgendwo in einer Map einer bestimmten instanz zugeordnet ist

ob dies dann z.b. durch die map des handlers aufgelöst wird ... und die eventlistener so angelegt sind (sein müssen) das sie diese information aus dem event ziehen ... ist doch egal ...


das ist 1zu1 genau dasselbe wie die frage : wie bestimme ich die auszuführene methode ?


und selbst WENN ich ein array mit den instanzen habe ... muss ich selbst DANN immer noch mit if(x instanceof A) prüfen ... womit wir wieder ganz vorne am eingangspost sind :

if (methodenName.equals("methode1")) { methode1(); }

 

[Ruzmanz]

 ... aber gucken wir uns doch mal z.b. OSGi bzw dessen implementierung in eclipse an
ich geb zu, ich hab davon null plan, aber was wird dort denn so sehr viel "besser" umgesetzt als bei meinem code ?

eclipse gibt über OSGi auch nur ein (bzw mehrere) interface vor nach dem dann die modul-klassen zu basteln sind

und dabei kann eclipse ach nicht alles vorgeben was möglich ist

Habe nie behauptet, dass bei einem unveränderbaren System alles Möglich ist, sofern kein JIT-Interpreter genutzt wird. Kenne mich mit OSGi eher weniger aus, aber ich spekuliere mal, dass es nicht möglich ist mit dem Plugin "Hack" auf ein anderes Plugin auszulesen, wo ich Verbindungsdaten+Passwörter eingebe? Nun könnte jemand kommen und sagen: "Hey, wir haben 2 Plugins in unseren Unternehmen, warum kann ich die Verbindungsdaten von meinen anderen Plugin nicht nutzen. Das wäre doch sinvoll." ... Ich nehme an, dass sich die Leute einen gewissen Rahmen überlegt haben, was Plugins dürfen.

und selbst wenn man das ganze runterbricht auf ein "Executable"-interface das dann nur eine methode "execute()" vorgibt, so scheitert es doch schon alleine an den parametern und den möglichen exceptions

die parameter bekommt man relativ einfach in den griff : Object[] ... einzige möglichkeit
bezüglich den exceptions, klar, man kann wild RuntimeExceptions schmeißen (wobei man exceptions ja eh grundsätzlich nie zur programmflusssteuerung nutzt !) ... man kann aber auch z.b. eine "ModulException" als checked Exception vorgeben in die dann alles rein muss ... also ggf auch unchecked RuntimeException

Den oben gepostet Code nutzt niemand. Ich erlaube dir deine zwei Anforderungen zu implementieren und meinen Code dementsprechend zu ändern ...

das "I" als prä-fix für ein Interface ist in java unüblich und wird eher im C-raum genutzt

Ich nutze es trotzdem gerne, da man hier im Forum nicht sehen kann ob es sich nun um ein Interface, Klasse, Enum oder Abstrakte Klasse handelt ... das "I" ist intuitiv, sodass ich mir 3 Zeilen für den Interface-Code sparen kann

 

[lawila]

wie ich sagte : auch ich hab von OSGi nicht wirklich n plan ... kann mir aber eben genau wie du durch aus vorstellen das sich irgendwer ein konzet erdacht hat : das und das geht so und so ... und sonst nichts ...
gut, widerspricht meiner vorstellung etwas weshalb meine paar klassen da recht "offen" sind ... aber wie gesagt ... war auch nur test-code und für mich selbst


bezüglich der schreibweise "mit I oder ohne ?" gibt es eine ganz klare vorgabe in java : Code Conventions for the Java Programming Language: 9. Naming Conventions
dort ist beim type "interface" ganz klar angeben wie es zu sein hat
wäre "I" wirklich java-gebräuchlich würde man es dort dann auch so finden

bezüglich des "man kanns nicht klar erkennen" ... ähm ... doch, und zwar erstens anhand der modifier und zweitens anhand der bezeichnung ...
gut, das jetzt kein unterscheidungsmerkmal zwischen interfac, klasse und enum gibt ... stimmt schon ... aber abstrakte klassen werden wie gesagt in der regel mit dem prä-fix Abstract kenntlich gemacht