# Methoden Liste durchlaufen



## dadom110 (16. Juni 2009)

Hallo Zusammen,

der Titel ist warscheinlich nicht besonder Aussagekräftig, aber wusste nicht wie ich das ganze umschreiben sollte 

Ich habe ein Interface, das nur eine Methode deklariert ( doCheck() )
Dieses Interface wird in mehrer Ausführungen Implementiert (mal als Beispiel, NumberCheck, SpellCheck ... etc)
Jetzt möchte ich in meinem Programm möglichst flexibel diese Prüfungsklassen miteinander kombinieren. Aus Scriptsprachen-Sicht sind ist mir sofort eine Liste aus  Referenzen auf die Methoden eingefallen die am Anfang des Programms einfach deklariert werden und die dann durchlaufen werden könnnte. Leider geht das ganze in Java so direkt leider nicht (über Umwege per Reflection könnte es gehen) Jemand eine gute Idee wie man das ganze am flexibelsten Implementieren könnte?

Das andere Problem auf das ich gestoßen bin: Die Implementierungen der Check-Klassen brauchen ja eigentlich nicht instanziiert werden, darum würden statische Methoden ausreichen...leider kann ich im Interface keine Methode als static deklarieren?

Danke schon mal für die Hilfe
D


----------



## Adrian_Broher (16. Juni 2009)

Das Decorator Pattern ist dein Freund.


----------



## dadom110 (17. Juni 2009)

Super. Hatte mich die Tage sogar schon in das Thema  eingelesen...aber bis man so was verinnerlich hat und sofort darauf kommt es zu verwenden, dauert es wohl etwas länger.

Strukturell sieht es dann so aus:

```
//******  CheckTask.java  ******
package kto.change;
public abstract class CheckTask {
	CheckTask innerTask;
	public abstract boolean doTest(Object ob);
	public CheckTask() {}
	public CheckTask(CheckTask task){innerTask=task;}
	public boolean deliverTestResult(boolean localResult, Object ob){
		if (innerTask==null)
			return localResult;
		else
			return (localResult && innerTask.doTest(ob));
	}
}

//*****  CheckChars.java  ******
package kto.change;
public class CheckChars extends CheckTask {
	public CheckChars(CheckTask task) {
		super(task);
	}
	public CheckChars() {
		super();
	}
	public boolean doTest(Object ob) {
		boolean result=true;
		return deliverTestResult(result,ob);
	}
}
//****  CheckNumbers.java  *****
package kto.change;
public class CheckNumbers extends CheckTask {
	public CheckNumbers(CheckTask task) {
		super(task);
	}
	public CheckNumbers() {
		super();
	}
	public boolean doTest(Object ob) {
		boolean result=true;
		return deliverTestResult(result,ob);
	}
}


//*****  FileChecker.java  ****
package kto.change;
import java.io.BufferedWriter;
public class FileChecker {
	private static BufferedWriter bWriter;
	public static void main(String[] args) {
		CheckTask tasks=new CheckChars(new CheckNumbers());
		System.out.println(tasks.doTest("sds"));
	}
}
```

Danke erst mal bisher, wenn noch Verbesserungs-Ideen da sind, immer mal her damit.

Viele Grüße
D


----------



## Adrian_Broher (17. Juni 2009)

Die "deliverTestResult" Methode sollte protected sein, da ja nur von "CheckTask" abgeleitete Klassen diese Methode aufrufen sollen.
Die Klassen und die Interfaces an sich sollten meines Erachtens als Generics implementiert werden.

Ansonsten erkenne ich wenig Sinn an deinem Vorhaben deiner Idee, was aber auch an den Beispielchecks liegen kann.


----------



## dadom110 (17. Juni 2009)

Ok, hört sich plausibel an, dank Dir.



Adrian_Broher hat gesagt.:


> Ansonsten erkenne ich wenig Sinn an deinem Vorhaben deiner Idee, was aber auch an den Beispielchecks liegen kann.



Das siehst du Richtig  in dem Beispiel fehlt natürlich die Implementierung der Tests

Grüße
D


----------



## Thomas Darimont (17. Juni 2009)

Hallo,

hier mal noch ne andere Möglichkeit:

```
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class CheckerExample {
	public static void main(String[] args) {
		new Validator().with(new Validator0(), new Validator1()).with(new Validator2()).validate("Bubu");
	}

	static interface IValidator {
		void validate(Object target);
	}

	static class AbstractValidator implements IValidator {
		public void validate(Object target) {
			System.out.println(target +" "+ getClass().getName());
		}
	}

	static class Validator0 extends AbstractValidator {
	}

	static class Validator1 extends AbstractValidator {
	}

	static class Validator2 extends AbstractValidator {
	}

	static class Validator implements IValidator {
		List<IValidator> validators = new ArrayList<IValidator>();
		public void validate(Object target) {
			for (IValidator validator : validators) {
				validator.validate(target);
			}
		}

		public Validator with(IValidator... validators) {
			this.validators.addAll(Arrays.asList(validators));
			return this;
		}
	}
}
```

Ausgabe:

```
Bubu com.dacos.training.CheckerExample$Validator0
Bubu com.dacos.training.CheckerExample$Validator1
Bubu com.dacos.training.CheckerExample$Validator2
```

Gruß Tom


----------

