Liste aller implementierenden Klassen einer Oberklasse anzeigen

[kirdie]

Ich habe eine Menge von Methoden, die in eine Klasse gekapselt sind, denn man kann ja in Java keine Funktionen als Parameter nehmen.
Jetzt möchte ich den Benutzer aber auswählen lassen, welche Methode er nehmen will. Allerdings möchte ich das nicht hardcoden, da ja später Methoden dazukommen könnten.
Hier mal ein einfaches Beispiel:

public interface Algorithm
{
 public static String getDescription();
 public int exec(int param1, int param2);
}

public class Addition implements Algorithm
{
@Override
public static String getDescription() {return "Addition";}
@Override
 public int exec(int param1, int param2) {return param1+param2;}
}

Jetzt soll der Benutzer angezeigt bekommen, welche Methoden es alles gibt, und zwar ungefähr so (pseudocode):

System.out.println("Which algorithm do you want to use?");
for(Class<Algorithm> algorithmClass: implementingClassesOf(Algorithm) )
{
 System.out.println(algorithmClass.getDescription());
 boolean useThis = input.nextBoolean();
 if(useThis)
 {
  new algorithmClass().exec(param1, param2);
 }
}

Problem dabei ist jetzt erstens, dass es sowas wie "implementingClassesOf" nicht gibt und zweitens, dass man keine statischen Methoden von Klassen aufrufen kann. Das finde ich jedoch unlogisch. Wenn ich String.valueOf() mache, brauche ich ja kein Objekt, sondern nur eine Klasse und "String" ist ja eine Klasse. Deshalb müsste doch "String.getClass()" eigentlich das gleiche sein, wie "String", aber da es das nicht ist, kann mir jemand erklären, warum?

Alternative:
Um das zu umgehen, habe ich mir folgendes überlegt:

public class Algorithms()
{
 public static final Algorithm[] algorithms = {new Addition(), new Subtraktion()};
}

Jetzt könnte man folgendes schreiben:

System.out.println("Which algorithm do you want to use?");
for(Algorithm algorithm: Algorithms.algorithms )
{
 System.out.println(algorithm.getDescription());
 boolean useThis = input.nextBoolean();
 if(useThis)
 {
  algorithm.exec(param1, param2);
 }
}

Das hat jedoch folgende Nachteile:

- man braucht eine zusätzliche Klasse (hier "Algorithms")
- dort müssen die Klassen manuell eingetragen werden, also jedesmal ein Eintrag hinzugefügt werden, wenn eine neue Unterklasse dazu kommt
- es wird eine statische Methode von einem Objekt aufgerufen, durch Vererbung kann da also auch die falsche aufgerufen werden
- es kann ein Overhead durch Konstruktorinitialisierung entstehen. Nehmen wir an, es dauert 1 Minute die Klasse "HyperdimensionaleAddition" zu initialisieren, wobei gar nicht garantiert ist, dass diese auch benutzt wird
- bei jedem Aufruf eines Algorithmus kann ein neues Ergebnis herauskommen, wenn durch die vorhergehenden Aufrufe Felder der Instanz modifiziert wurden
- der Algorithmus kann in einen ungültigen Zustand kommen und nicht mehr funktionieren, dann kann die Methode nicht mehr aufgerufen werden (das würde umgangen werden, wenn jedes mal eine neue Instanz erzeugt wird)

Die letzten beiden Punkte kann man natürlich durch sorgfältige Programmierung vermeiden. Das Argument des Overheads kann auch gegen eine Neuinitialisierung verwendet werden, weil dann zwar nicht alle möglichen Algorithmen im vorraus initialisiert werden würden, aber dafür ein Algorithmus mehrmals initialisiert wird. Das Problem mit der statischen Methode kann man beheben, indem man sie einfach nicht statisch macht.

Trotzdem bin ich mir noch nicht sicher, ob diese Alternative das Beste in dieser Situation ist und würde deshalb gerne wissen, was denn das Standardverfahren für diese Art Problem ist.

 

[Marco13]

Das reicht von der Verwendung eines eigenen ClassLoaders bis zu Dingen wie OSGi...

 

[SlaterB]

eine Enum ist eine schöne abgeschlossene Angelegenheit:
automatisch vorhandene Aufzählung + keine Möglichkeit zur Vererbung/ weitere Algorithmen

ein Class-Objekt ist etwas mit einer bestimmten Funktion, Auflistung der Methoden usw., hat nicht die Aufgabe dasselbe zu sein wie die Klasse hinsichtlich Aufruf statischer Methoden,
bei einem ganz allgemeinen Class-Objekt wäre das auch gar nicht möglich, das hat ja nichts mit einer bestimmten Klasse zu tun,

nur im begrenzten Gebiet der erst ab Java 1.5 hinzugekommenen Generics mit Class<Algorithm> und ähnlichem könnte man sich da etwas denken,
aber es gilt der Grundsatz: Objektorientierung, Vererbung, Interface usw. sind für Objekte gedacht, nicht für Klassen,
du brauchst nichts statisches, alles sinnvolle läßt sich auch ohne static implementieren,

wenn dich der Aufwand der Objekterzeugung stört, dann lege einmalig in einer Map Objekte an und verwende diese immer wieder,
was wieder zur Enum zurückführt -> jeder Enumwert ist ein Objekt der Klasse

> bei jedem Aufruf eines Algorithmus kann ein neues Ergebnis herauskommen, wenn durch die vorhergehenden Aufrufe Felder der Instanz modifiziert wurden
dann verwende eben keine Felder in den Algorithmus-Klassen.., das Problem gilt für statische Methoden genauso, wenn statische Felder modifiziert werden

 

[XHelp]

Die initialisierung von Operationen sollte eigentlich nichts machen. Da wird ja nichts berechnet. In Interfaces kannst du auch keine statischen Methoden angeben.
Hier mal auf die schnelle zussamen geschriebenes Beispiel, wie es laufen könnte, wobei manche Sachen definitiv zu verbesser sind, manche man auslagern könnte etc. Es geht eben nur um einen Gedankenanstoß

public interface Algorithm {
	public String getDescription();
	public Integer exec();
	public int getParameterCount();
	public void setParameter(int number, Integer value);
}

public class Addition implements Algorithm {
	int a = 0;
	int b = 0;

	@Override
	public String getDescription() {
		return "Addition";
	}

	@Override
	public Integer exec() {
		return a + b;
	}

	@Override
	public int getParameterCount() {
		return 2;
	}

	@Override
	public void setParameter(int number, Integer value) {
		if (getParameterCount() < number) {
			throw new IllegalArgumentException("Parameter existiert nicht");
		}
		switch (number) {
		case 0:
			a = value;
			break;

		case 1:

			b = value;
			break;
		}
	}

}

public class Square implements Algorithm {
	private Integer x;

	@Override
	public String getDescription() {
		return "Square";
	}

	@Override
	public Integer exec() {
		return x * x;
	}

	@Override
	public int getParameterCount() {
		return 1;
	}

	@Override
	public void setParameter(int number, Integer value) {
		if (getParameterCount() < number) {
			throw new IllegalArgumentException("Parameter existiert nicht");
		}
		x = value; 

	}
}

public class AlgoUtility {
	private static List<Class<? extends Algorithm>> algoList=null;
	static {
		algoList = new ArrayList<Class<? extends Algorithm>>();
		algoList.add(Addition.class);
		algoList.add(Square.class);
	}
	public static List<Class<? extends Algorithm>> getAlgorithmList() {
		return algoList;
	}
}

public class MainTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (Class<? extends Algorithm> currentAlgoClass:AlgoUtility.getAlgorithmList()) {
			try {
				Constructor c =  currentAlgoClass.getConstructor(null);
				Algorithm  currentAlgo = (Algorithm) c.newInstance(null);
				System.out.println("Algo '"+currentAlgo.getDescription()+"' benutzen?");
				if (sc.nextBoolean()) {
					for (int i=0;i<currentAlgo.getParameterCount();i++) {
						System.out.println("Parameter "+(i+1)+" eingeben:");
						Integer tmp = sc.nextInt();
						currentAlgo.setParameter(i, tmp);
					}
					System.out.println("Das Ergebnis ist: "+currentAlgo.exec());
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
}

Aber wie gesagt, eher ein Gedankenanstoß

 

[kirdie]

Vielen Dank für das ausführliche Beispiel XHelp! Ich werde es zwar jetzt doch nur mit Instanzen machen, da das in meinem Fall reicht aber falls ich mal die volle Funktionalität davon brauche werde ich das auf jeden Fall benutzen!