Modèle de modèle:
La méthode de modèle consiste à laisser les sous-classes redéfinir certaines étapes de l'algorithme, sans changer la structure principale et les étapes de l'algorithme, définies dans la classe de base. Le modèle de modèle utilise généralement l'héritage, de sorte qu'une implémentation générique d'algorithmes peut être fournie dans la classe de base, que la sous-classe peut choisir de remplacer si nécessaire.
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;
}
}
Notez que dans le code ci-dessus, les étapes de l'algorithme go () seront toujours les mêmes, mais les sous-classes peuvent définir une recette différente pour effectuer une étape particulière.
Modèle de stratégie:
Le modèle de stratégie consiste à laisser le client sélectionner l'implémentation d'algorithmes concrets au moment de l'exécution. Tous les algorithmes sont isolés et indépendants, mais implémentent une interface commune, et il n'y a aucune notion de définition d'étapes particulières dans l'algorithme.
/**
* 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);
}
}
}
Pour le code source complet, consultez mon référentiel github .
