Methodenausführung abhängig von vordefiniertem Wert?

[AndreasK.]

Hallo Zusammen,

ich habe eine kurze Frage.
Wie kann man in Java eine Methodenausführung abhängig von einem bestimmten vordefinierten Wert machen?
Natürlich könnte ich vor jede Methode eine if-Abfrage setzen, jedoch trägt dies nicht zur Übersicht bei und ist nicht sonderlich elegant.

Beispielsweise hat man drei verschiedene Geräte und je nachdem welches beim Ausführen des Programms gesetzt ist, möchte man gewisse Methoden ausführen und andere wiederrum nicht.

Pseudocode Bsp.:
@Gerät("A") //also wenn gerät A dann führe Methode machX() aus usw.
machX();
@Gerät("B")
machY();
@Gerät("A,B")
machZ();

Geht dass vielleicht irgendwie mit Annotations oder ähnlichem?


Danke im Vorraus
Andreas

 

[tfa]

Wie wär's mit Objektorientierung?
Es gibt ein Interface, das die Methode definiert. Jedes Gerät besitzt eine eigene Implementierung dieses Interfaces mit der entsprechenden Methode. Jetzt musst du nur dafür sorgen, dass jedem Gerät das korrekte Objekt zugeordnet wird.

 

[Michael...]

Hab's zwar noch nicht ganz verstanden um was es genau geht, würde Dir aber aufgrund folgender Zeilen raten Dich mit dem Thema Vererbung auseinander zu setzen.

Beispielsweise hat man drei verschiedene Geräte und je nachdem welches beim Ausführen des Programms gesetzt ist, möchte man gewisse Methoden ausführen und andere wiederrum nicht.

 

[AndreasK.]

Zuerst einmal vielen Dank für die schnellen Antworten. Aber ich glaub es wurde nicht richtig verstanden.

@tfa
Es geht nicht um den Ablauf der Methode, sondern um den Methoden aufruf selbst.
D.h. Ob die Methode ausgeführt werden soll oder nicht

Pseudocode Bsp.:
@Gerät("A") //also wenn gerät A dann führe Methode machX() aus usw.
machX();
@Gerät("B")
machY();
@Gerät("A,B")
machZ();

@Michael
Danke aber mit Vererbung kenne ich mich ganz gut aus

 

[Landei]

Objektorientierung ist schon richtig.

public abstract class BaseClass {
   public void machX() { /*Implementierung*/ } 
   public void machY() { /*Implementierung*/ } 
   public void machZ() { /*Implementierung*/ } 
}

public class AClass extends BaseClass {
  public void machY() { /* tu nix*/ }
}

public class BClass extends BaseClass{
  public void machX() { /* tu nix*/ }
}

 

[AndreasK.]

Stimmt ja alles soweit, nur deckt es sich nicht mit meinem Anwendungsfall.

Zum Hintergrund:
Ich habe für eine Geräteserie Testfälle geschrieben. In diesen Testfällen werden zum Teil an die 800 Methoden aufgerufen, wobei es sich ca. um 50 verschieden Methoden handelt(wachsend).
Aktuell ist eine neue Geräteklasse hinzugekommen, bei der einige Methodenaufrufe wegfallen und einige neue dazukommen.
Zugunsten der Wartbarkeit, Konsistenz etc. möchte ich jedoch nicht einfach den Inhalt der Testfälle kopieren und an die neue Geräteklasse anpassen, sondern die Anpassungen durch Metainfos oder ähnliches durchführen.
D.h. ich möchte mit einer Metainformationen vorher angeben, ob die folgende Methode bzw. mehrere folgenden Methoden in abhängigkeit von Gerätetyp ausgeführt werden müssen oder nicht.
Es muss ja in Programmen auch einen Mechanismuss geben, der zwischen der Ausführung auf Windows XP, Vista oder 7 unterscheidet. Und ich glaube nicht dass, das Ganze durch if-else-Zweige gelöst wird. (Vobei bei Microsoft weiß man ja nie )

Ich hoffe das zeigt die Problematik

 

[Michael...]

Kann man diese Methoden vielleicht gruppieren, um dann mit wenigen Interfaces zu arbeiten und somit mit weniger if else Zweigen? Aber ganz ohne if-else wird's wohl nicht funktionieren.
Aber vielleicht habe ich das ganze immer noch nicht ganz verstanden. Eventuell kannst Du ja mal ein kurzes Bsp Programm posten.

 

[Wortraum]

Wenn man in den Metainformationen die Methodennamen hat, die aufgerufen werden soll, könnte man es über Reflections lösen.

 

[Noctarius]

AspectJ

 

[AndreasK.]

@Michael
Zuerst einmal Danke für deine Tipps und Lösungsvorschläge.
Ich kann leider keinen Codeauszug geben, da ich neben meinem Studium in einem Unternehmen daran arbeite.

Aber ichs versuchs nochmal exemplarisch zu verdeutlichen:
(Vielleicht war das vorherige Beispiel nicht so der hit)

//1. das hier soll für Gerät A ausgeführt werden, da diese Funktion speziell in Gerät A
methodeX(...);
methodeX(...);
methodeY(...);
methodeX(...);
//2. das hier soll für Gerät B ausgeführt werden, da diese Funktion speziell in Gerät B
methodeX(...);
methodeY(...);
methodeX(...);
methodeX(...);
methodeY(...);
//3. dann hier vielleicht ein Abschnitt der für beide Geräte gilt, da Funktionen in beiden getestet werden
methodeX(...);
methodeX(...);
methodeY(...);
//4. das hier dann wieder nur für Gerät B
methodeX(...);
methodeY(...);
//5. das hier dann wieder nur für Gerät A
methodeY(...);
methodeY(...);

die Methodenaufrufe müssen in dieser zeitlichen Reihenfolge ablaufen

Bemerkung: methodeX(...) stellt zum Beispiel eine GUI Navigation zu einem Menüziel dar und wird daher so häufig aufgerufen. MethodeY(...) könnte bspw. ein Knopfdruck sein.

Also es kann nicht anhand der Parameter oder ähnlichem unterschieden werden.
Ich hab lediglich die Bezeichner von mir aus "NeuesModell" & "AltesModell".

 

[Noctarius]

Dann definierst du ein Interface z.B. mit der Methode "execute()". Innerhalb der Implementierung dieser Interface-Methode (welche für jedes Gerät anders ist) rufst du die von diesem Gerät benötigten Methoden auf.

Insgesamt ist dieser Ansatz auch übersichtlicher, weil du nicht tausende Methoden durchschauen musst um zu sehen in welchen Annotations Gerät A mit enthalten ist sondern du schaust in die Methode execute der Interfaceimplementierung von Gerät A und siehst in schönstem (hoffentlich) Java, was für dieses Gerät ausgeführt wird.

 

[AndreasK.]

@Noctarius
würde schon stimmen wenn ich nur einen Test durchzuführen hätte.

Jedoch hat jedes Gerät ca. 50 Tests, wobei jeder Test als eine Java Klasse repräsentiert wird.
D.h. ich kann keine zentrale execute() Methode mit all den auszuführenden Methoden schreiben, da es sich bei jedem Testfall um andere Methoden handelt.

EDIT: Ich habe das letzt Beispiel nochmal erweitert.

 

[Noctarius]

Dann hilft dir auch ein Annotation nicht, da du auch hier nicht drin hast für welchen Testfall welche Methode gilt, dann müsstest du eine Kombination aus Testfall und Gerät an jede Methode (und für jedes Gerät und jeden Testfall) kleben. 500 Annotations für 50 Testfälle und 10 Geräte finde ich unschön ;-)

 

[AndreasK.]

Ja die Menge ist dass Problem, daher Suche ich ja nach einer eleganteren Lösung

 

[Leroy42]

Jedoch hat jedes Gerät ca. 50 Tests, wobei jeder Test als eine Java Klasse repräsentiert wird.

Ein Test der als Java-Klasse repräsentiert wird?

Irgendwas stimmt da in deinem Ansatz total nicht! ;(

 

[Noctarius]

Dann mach 2 Interfaces:
ITest und IGerät

 

[AndreasK.]

@Leroy42
Die Test sind sehr umfangreich und aus Gründen der Übersicht,Logik,Laufzeit etc. in verschiedene Funktionsgruppen unterteilt. Wobei hierbei jeder Test schon an die 1000 Zeilen Code einnimmt. Bsp. wird in einem Test der Funktionszweig A der Applikation und in einem anderen der Funtkionszweig B der Applikation getestet. Es handelt sich hierbei nicht um eine Applikation die ich in 2 Tagen geschrieben habe, sondern um eine Applikation die das Unternehmen geschätzte 15 Jahre vertreibt.

 

[Leroy42]

sondern um eine Applikation die das Unternehmen geschätzte 15 Jahre vertreibt.

Ohh schon 2 Jahre bevor es Java überhaupt gab?

Java (Programmiersprache) ? Wikipedia

Zitat: Erscheinungsjahr 1996

 

[0x7F800000]

Aber ichs versuchs nochmal exemplarisch zu verdeutlichen:
(Vielleicht war das vorherige Beispiel nicht so der hit)

//das hier soll für Gerät A ausgeführt werden, da diese Funktion speziell in Gerät A
methodeX(...);
methodeX(...);
methodeY(...);
methodeX(...);
//das hier soll für Gerät B ausgeführt werden, da diese Funktion speziell in Gerät B
methodeX(...);
methodeY(...);
methodeX(...);
methodeX(...);
methodeY(...);
//dann hier vielleicht ein Abschnitt der für beide Geräte gilt, da Funktionen in beiden getestet werden
methodeX(...);
methodeX(...);
methodeY(...);

Bemerkung: methodeX(...) stellt zum Beispiel eine GUI Navigation zu einem Menüziel dar und wird daher so häufig aufgerufen. MethodeY(...) könnte bspw. ein Knopfdruck sein.

Also es kann nicht anhand der Parameter oder ähnlichem unterschieden werden.
Ich hab lediglich die Bezeichner von mir aus "NeuesModell" & "AltesModell".

Ich versteh's immer noch nicht... statt nur dauernd "methodeX methodeY" hinzuschreiben, hättest du schon vor langer zeit wenigstens mal grob skizzieren können, was A und B überhaupt sind (Klassen, Instanzen?) und wo diese XY-methoden überhaupt stehen... :bahnhof: Unter einem "Gerät" kann sich nun mal jeder vorstellen, was er will, das ist irgendwie keine feste Diskussionsgrundlage... ???:L

wieso kannst du nicht einfach eine Liste mit Objekten, an den irgendwas gemacht werden soll, diesen XY-methoden übergeben?

edit:
hab mir mal den spaß erlaubt, irgendwelchen Murks mit Annotationen zusammenzubasteln... Nicht hauen: ist jetzt überhaupt das erste mal, dass ich eine Annotation definiert habe, ehrlich gesagt weiß ich immer noch nicht so recht, was ich damit soll^^

import java.lang.reflect.*;
import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;

public class _ {
	
	private static interface TestedArticle{
		void pressButton();
		void dropFromHeight(int meters);
		void broil(int minutes);
	}
	
	private static class Ball implements TestedArticle{
		
		public Ball(){}
		
		@Override
		public void broil(int minutes) {
			System.out.println(minutes>2?"ouch, i'm melting":"loosing original color...");
		}

		@Override
		public void dropFromHeight(int meters) {
			System.out.println("bouncy bounce");
		}

		@Override
		public void pressButton() {
			System.out.println("there are no buttons there");
		}
	}
	
	private static class CellPhone implements TestedArticle{
		
		public CellPhone(){}
		
		@Override
		public void broil(int minutes) {
			System.out.println("broken");
		}

		@Override
		public void dropFromHeight(int meters) {
			System.out.println(meters>3?"broken":(meters>1?"display cracked":"everything ok"));
		}

		@Override
		public void pressButton() {
			System.out.println("beeep");
		}
	}
	
	@Retention(value=RUNTIME)
	@Target(value=METHOD)
	private static @interface Test{
		String 								name();
		Class<? extends TestedArticle>[] 	targets();
	}
	
	@Test(name="big drop",targets={Ball.class})
	private static void methodX(TestedArticle t){
		for(int h=1; h<10; h++)t.dropFromHeight(h);
	}
	
	@Test(name="small drop",targets={Ball.class,CellPhone.class})
	private static void methodY(TestedArticle t){
		t.dropFromHeight(1);
		t.pressButton();
	}
	
	@Test(name="broiling",targets={Ball.class,CellPhone.class})
	private static void methodZ(TestedArticle t){
		t.broil(5);
		t.pressButton();
	}
	
	public static void main(String...args){
		for(Method m:_.class.getDeclaredMethods()){
			Test annotation=m.getAnnotation(Test.class);
			if(annotation!=null){
				System.out.println("====================Test: "+annotation.name());
				for(Class<? extends TestedArticle> clazz:annotation.targets()){
					try {
						System.out.println("------------Tested class: "+clazz.getSimpleName());
						m.invoke(null, clazz.getConstructors()[0].newInstance((Object[])null));
					} catch (Exception e) {
						e.printStackTrace();
					}		
				}
			}
		}
	}
}

 

[Noctarius]

Jetzt müssten theoretisch nur noch mehrere Test-Annotations an eine Klasse kommen können, damit ich mehrere "Testsorten" definieren kann. Alles in allem, extrem unschön!

 

[Leroy42]

hättest du schon vor langer zeit wenigstens mal grob skizzieren können, was A und B überhaupt sind (Klassen, Instanzen?) und wo diese XY-methoden überhaupt stehen... :bahnhof: Unter einem "Gerät" kann sich nun mal jeder vorstellen, was er will, das ist irgendwie keine feste Diskussionsgrundlage... ???:L

Das sehe ich genauso! ???:L