Vorlagenmuster:
Bei der Vorlagenmethode geht es darum, Unterklassen bestimmte Schritte des Algorithmus neu definieren zu lassen, ohne die in der Basisklasse definierte Hauptstruktur und die Schritte des Algorithmus zu ändern. Das Vorlagenmuster verwendet normalerweise die Vererbung, sodass eine generische Implementierung von Algorithmen in der Basisklasse bereitgestellt werden kann, die die Unterklasse bei Bedarf möglicherweise überschreibt.
public abstract class RobotTemplate {
/* This method can be overridden by a subclass if required */
public void start() {
System.out.println("Starting....");
}
/* This method can be overridden by a subclass if required */
public void getParts() {
System.out.println("Getting parts....");
}
/* This method can be overridden by a subclass if required */
public void assemble() {
System.out.println("Assembling....");
}
/* This method can be overridden by a subclass if required */
public void test() {
System.out.println("Testing....");
}
/* This method can be overridden by a subclass if required */
public void stop() {
System.out.println("Stopping....");
}
/*
* Template algorithm method made up of multiple steps, whose structure and
* order of steps will not be changed by subclasses.
*/
public final void go() {
start();
getParts();
assemble();
test();
stop();
}
}
/* Concrete subclass overrides template step methods as required for its use */
public class CookieRobot extends RobotTemplate {
private String name;
public CookieRobot(String n) {
name = n;
}
@Override
public void getParts() {
System.out.println("Getting a flour and sugar....");
}
@Override
public void assemble() {
System.out.println("Baking a cookie....");
}
@Override
public void test() {
System.out.println("Crunching a cookie....");
}
public String getName() {
return name;
}
}
Beachten Sie im obigen Code, dass die Schritte des go () -Algorithmus immer gleich sind, die Unterklassen jedoch möglicherweise ein anderes Rezept für die Ausführung eines bestimmten Schritts definieren.
Strategiemuster:
Beim Strategiemuster geht es darum, den Client zur Laufzeit die Implementierung konkreter Algorithmen auswählen zu lassen. Alle Algorithmen sind isoliert und unabhängig, implementieren jedoch eine gemeinsame Schnittstelle, und es gibt keine Vorstellung davon, bestimmte Schritte innerhalb des Algorithmus zu definieren.
/**
* This Strategy interface is implemented by all concrete objects representing an
* algorithm(strategy), which lets us define a family of algorithms.
*/
public interface Logging {
void write(String message);
}
/**
* Concrete strategy class representing a particular algorithm.
*/
public class ConsoleLogging implements Logging {
@Override
public void write(String message) {
System.out.println(message);
}
}
/**
* Concrete strategy class representing a particular algorithm.
*/
public class FileLogging implements Logging {
private final File toWrite;
public FileLogging(final File toWrite) {
this.toWrite = toWrite;
}
@Override
public void write(String message) {
try {
final FileWriter fos = new FileWriter(toWrite);
fos.write(message);
fos.close();
} catch (IOException e) {
System.out.println(e);
}
}
}
Den vollständigen Quellcode finden Sie in meinem Github- Repository .
