Vorlagen
Eine der häufigsten Anforderungen bei offenen Stellen ist „Musterkenntnis“. Zunächst lohnt es sich, eine einfache Frage zu beantworten: „Was ist ein Designmuster?“ Muster wird aus dem Englischen als „Vorlage“ übersetzt. Das heißt, das ist ein bestimmtes Muster, nach dem wir etwas tun. Das Gleiche gilt auch für die Programmierung. Es gibt einige etablierte Best Practices und Ansätze zur Lösung häufiger Probleme. Jeder Programmierer ist ein Architekt. Selbst wenn Sie nur wenige Klassen oder sogar nur eine erstellen, hängt es von Ihnen ab, wie lange der Code unter sich ändernden Anforderungen überleben kann und wie bequem er von anderen verwendet werden kann. Und hier helfen Kenntnisse über Vorlagen, denn... Auf diese Weise können Sie schnell verstehen, wie Sie Code am besten schreiben, ohne ihn neu zu schreiben. Wie Sie wissen, sind Programmierer faule Leute und es ist einfacher, etwas sofort gut zu schreiben, als es mehrmals zu wiederholen. Muster können auch Algorithmen ähneln. Aber sie haben einen Unterschied. Der Algorithmus besteht aus spezifischen Schritten, die die notwendigen Aktionen beschreiben. Muster beschreiben lediglich die Vorgehensweise, nicht jedoch die Umsetzungsschritte. Die Muster sind unterschiedlich, weil... verschiedene Probleme lösen. Typischerweise werden folgende Kategorien unterschieden:-
Generativ
Diese Muster lösen das Problem, die Objekterstellung flexibel zu gestalten
-
Strukturell
Diese Muster lösen das Problem des effektiven Aufbaus von Verbindungen zwischen Objekten
-
Verhalten
Diese Muster lösen das Problem einer effektiven Interaktion zwischen Objekten
Schöpfungsmuster
Beginnen wir am Anfang des Lebenszyklus von Objekten – mit der Erstellung von Objekten. Generative Vorlagen helfen dabei, Objekte bequemer zu erstellen und bieten Flexibilität in diesem Prozess. Einer der bekanntesten ist „ Builder “. Mit diesem Muster können Sie komplexe Objekte Schritt für Schritt erstellen. In Java ist das bekannteste BeispielStringBuilder:
class Main {
public static void main(String[] args) {
StringBuilder builder = new StringBuilder();
builder.append("Hello");
builder.append(',');
builder.append("World!");
System.out.println(builder.toString());
}
}java.util.Calendar. Die Klasse selbst Calendarist abstrakt und um sie zu erstellen, wird die Methode verwendet getInstance:
import java.util.*;
class Main {
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime());
System.out.println(calendar.getClass().getCanonicalName());
}
}Calendarund es wird eine Klasse erstellt GregorianCalendar. Wenn wir uns den Konstruktor ansehen, können wir sehen, dass je nach Bedingungen unterschiedliche Implementierungen erstellt werden Calendar. Aber manchmal reicht eine Fabrikmethode nicht aus. Manchmal müssen Sie verschiedene Objekte erstellen, damit sie zusammenpassen. Dabei hilft uns eine weitere Vorlage – „ Abstract Factory “. Und dann müssen wir verschiedene Fabriken an einem Ort schaffen. Gleichzeitig liegt der Vorteil darin, dass uns die Details der Umsetzung nicht wichtig sind, d.h. Es spielt keine Rolle, welche konkrete Fabrik wir bekommen. Die Hauptsache ist, dass es die richtigen Umsetzungen schafft. Superbeispiel:
java.lang.Cloneable:
class Main {
public static void main(String[] args) {
class CloneObject implements Cloneable {
@Override
protected Object clone() throws CloneNotSupportedException {
return new CloneObject();
}
}
CloneObject obj = new CloneObject();
try {
CloneObject pattern = (CloneObject) obj.clone();
} catch (CloneNotSupportedException e) {
//Do something
}
}
}
clone. Das heißt, die Erstellung eines Objekts auf der Grundlage eines Prototyps liegt in der Verantwortung des Objekts selbst. Dies ist nützlich, da der Benutzer dadurch nicht an die Implementierung des Vorlagenobjekts gebunden ist. Nun, das allerletzte auf dieser Liste ist das „Singleton“-Muster. Sein Zweck ist einfach: eine einzelne Instanz des Objekts für die gesamte Anwendung bereitzustellen. Dieses Muster ist interessant, da es häufig Multithreading-Probleme aufweist. Weitere Informationen finden Sie in den folgenden Artikeln:
Strukturelle Muster
Mit der Erstellung von Objekten wurde es klarer. Jetzt ist es an der Zeit, strukturelle Muster zu betrachten. Ihr Ziel ist es, einfach zu unterstützende Klassenhierarchien und deren Beziehungen aufzubauen. Eines der ersten und bekanntesten Muster ist „ Deputy “ (Proxy). Der Proxy verfügt über dieselbe Schnittstelle wie das reale Objekt, sodass es für den Client keinen Unterschied macht, ob er über den Proxy oder direkt arbeitet. Das einfachste Beispiel ist java.lang.reflect.Proxy :import java.util.*;
import java.lang.reflect.*;
class Main {
public static void main(String[] arguments) {
final Map<String, String> original = new HashMap<>();
InvocationHandler proxy = (obj, method, args) -> {
System.out.println("Invoked: " + method.getName());
return method.invoke(original, args);
};
Map<String, String> proxyInstance = (Map) Proxy.newProxyInstance(
original.getClass().getClassLoader(),
original.getClass().getInterfaces(),
proxy);
proxyInstance.put("key", "value");
System.out.println(proxyInstance.get("key"));
}
}HashMapdas die Schnittstelle implementiert Map. Als nächstes erstellen wir einen Proxy, der den ursprünglichen Proxy HashMapfür den Client-Teil ersetzt, der die Methoden putund aufruft getund während des Aufrufs unsere eigene Logik hinzufügt. Wie wir sehen können, erfolgt die Interaktion im Muster über Schnittstellen. Aber manchmal reicht ein Ersatz nicht aus. Und dann kann das „ Decorator “-Muster verwendet werden. Ein Dekorator wird auch Wrapper oder Wrapper genannt. Proxy und Decorator sind sich sehr ähnlich, aber wenn Sie sich das Beispiel ansehen, werden Sie den Unterschied erkennen:
import java.util.*;
class Main {
public static void main(String[] arguments) {
List<String> list = new ArrayList<>();
List<String> decorated = Collections.checkedList(list, String.class);
decorated.add("2");
list.add("3");
System.out.println(decorated);
}
}import java.util.*;
class Main {
public static void main(String[] arguments) {
String[] array = {"One", "Two", "Three"};
List<String> strings = Arrays.asList(array);
strings.set(0, "1");
System.out.println(Arrays.toString(array));
}
}List. Wenn wir damit arbeiten, arbeiten wir tatsächlich mit einem Array. Daher funktioniert das Hinzufügen von Elementen nicht, weil... Das ursprüngliche Array kann nicht geändert werden. Und in diesem Fall erhalten wir UnsupportedOperationException. Der nächste interessante Ansatz zur Entwicklung einer Klassenstruktur ist das Composite- Muster . Das Interessante daran ist, dass ein bestimmter Satz von Elementen, die eine Schnittstelle verwenden, in einer bestimmten baumartigen Hierarchie angeordnet ist. Durch den Aufruf einer Methode für ein übergeordnetes Element erhalten wir einen Aufruf dieser Methode für alle erforderlichen untergeordneten Elemente. Ein Paradebeispiel für dieses Muster ist die Benutzeroberfläche (sei es java.awt oder JSF):
import java.awt.*;
class Main {
public static void main(String[] arguments) {
Container container = new Container();
Component component = new java.awt.Component(){};
System.out.println(component.getComponentOrientation().isLeftToRight());
container.add(component);
container.applyComponentOrientation(ComponentOrientation.RIGHT_TO_LEFT);
System.out.println(component.getComponentOrientation().isLeftToRight());
}
}java.awt:
Verhaltensmuster
Wir haben also herausgefunden, wie Objekte erstellt und Verbindungen zwischen Klassen organisiert werden können. Das Interessanteste, was noch übrig ist, besteht darin, Flexibilität bei der Änderung des Verhaltens von Objekten bereitzustellen. Und Verhaltensmuster werden uns dabei helfen. Eines der am häufigsten genannten Muster ist das „ Strategie “-Muster. Hier beginnt das Studium der Muster im Buch „ Head First. Design Patterns “. Mithilfe des „Strategie“-Musters können wir in einem Objekt speichern, wie wir die Aktion ausführen, d. h. Das darin enthaltene Objekt speichert eine Strategie, die während der Codeausführung geändert werden kann. Dies ist ein Muster, das wir häufig verwenden, wenn wir einen Komparator verwenden:import java.util.*;
class Main {
public static void main(String[] args) {
List<String> data = Arrays.asList("Moscow", "Paris", "NYC");
Comparator<String> comparator = Comparator.comparingInt(String::length);
Set dataSet = new TreeSet(comparator);
dataSet.addAll(data);
System.out.println("Dataset : " + dataSet);
}
}TreeSet. Es hat das Verhalten, die TreeSetReihenfolge der Elemente beizubehalten, d. h. sortiert sie (da es sich um ein SortedSet handelt). Dieses Verhalten hat eine Standardstrategie, die wir im JavaDoc sehen: Sortieren in „natürlicher Reihenfolge“ (bei Strings ist dies die lexikografische Reihenfolge). Dies passiert, wenn Sie einen parameterlosen Konstruktor verwenden. Aber wenn wir die Strategie ändern wollen, können wir passen Comparator. In diesem Beispiel können wir unseren Satz als erstellen new TreeSet(comparator)und dann ändert sich die Reihenfolge der Speicherelemente (Speicherstrategie) in die im Komparator angegebene. Interessanterweise gibt es fast das gleiche Muster namens „ State “. Das Muster „Zustand“ besagt, dass wir, wenn wir im Hauptobjekt ein Verhalten haben, das vom Zustand dieses Objekts abhängt, den Zustand selbst als Objekt beschreiben und das Zustandsobjekt ändern können. Und delegieren Sie Anrufe vom Hauptobjekt an den Staat. Ein weiteres Muster, das uns aus dem Studium der Grundlagen der Java-Sprache bekannt ist, ist das „ Befehl “-Muster. Dieses Entwurfsmuster legt nahe, dass unterschiedliche Befehle als unterschiedliche Klassen dargestellt werden können. Dieses Muster ist dem Strategiemuster sehr ähnlich. Aber im Strategiemuster haben wir neu definiert, wie eine bestimmte Aktion ausgeführt werden würde (z. B. Sortieren in TreeSet). Im Muster „Befehl“ definieren wir neu, welche Aktion ausgeführt wird. Der Musterbefehl begleitet uns jeden Tag, wenn wir Threads verwenden:
import java.util.*;
class Main {
public static void main(String[] args) {
Runnable command = () -> {
System.out.println("Command action");
};
Thread th = new Thread(command);
th.start();
}
}java.util.logging:
import java.util.logging.*;
class Main {
public static void main(String[] args) {
Logger logger = Logger.getLogger(Main.class.getName());
ConsoleHandler consoleHandler = new ConsoleHandler(){
@Override
public void publish(LogRecord record) {
System.out.println("LogRecord обработан");
}
};
logger.addHandler(consoleHandler);
logger.info("test");
}
}logger.getHandlers) für diesen Logger. Ein weiteres Muster, das wir jeden Tag sehen, ist „ Iterator “. Sein Kern besteht darin, eine Sammlung von Objekten (z. B. eine Klasse, die eine Datenstruktur darstellt List) zu trennen und diese Sammlung zu durchlaufen.
import java.util.*;
class Main {
public static void main(String[] args) {
List<String> data = Arrays.asList("Moscow", "Paris", "NYC");
Iterator<String> iterator = data.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}java.nio.file.FileVisitor:
import java.nio.file.*;
import java.nio.file.attribute.*;
import java.io.*;
class Main {
public static void main(String[] args) {
SimpleFileVisitor visitor = new SimpleFileVisitor() {
@Override
public FileVisitResult visitFile(Object file, BasicFileAttributes attrs) throws IOException {
System.out.println("File:" + file.toString());
return FileVisitResult.CONTINUE;
}
};
Path pathSource = Paths.get(System.getProperty("java.io.tmpdir"));
try {
Files.walkFileTree(pathSource, visitor);
} catch (AccessDeniedException e) {
// skip
} catch (IOException e) {
// Do something
}
}
}import java.util.*;
class Main {
public static void main(String[] args) {
Observer observer = (obj, arg) -> {
System.out.println("Arg: " + arg);
};
Observable target = new Observable(){
@Override
public void notifyObservers(Object arg) {
setChanged();
super.notifyObservers(arg);
}
};
target.addObserver(observer);
target.notifyObservers("Hello, World!");
}
}java.util.Timer:
import java.util.*;
class Main {
public static void main(String[] args) {
Timer mediator = new Timer("Mediator");
TimerTask command = new TimerTask() {
@Override
public void run() {
System.out.println("Command pattern");
mediator.cancel();
}
};
mediator.schedule(command, 1000);
}
}Timer„a“ verborgen. Im Timer gibt es eine Aufgabenwarteschlange TaskQueueund einen Thread TimerThread. Als Clients dieser Klasse interagieren wir nicht mit ihnen, sondern mit Timerdem Objekt, das als Reaktion auf unseren Aufruf seiner Methoden auf die Methoden anderer Objekte zugreift, deren Vermittler es ist. Äußerlich mag es „Fassade“ sehr ähnlich erscheinen. Der Unterschied besteht jedoch darin, dass bei Verwendung einer Fassade die Komponenten nicht wissen, dass die Fassade existiert, und miteinander kommunizieren. Und wenn „Mediator“ verwendet wird, kennen und nutzen die Komponenten den Vermittler, nehmen jedoch keinen direkten Kontakt zueinander auf. Es lohnt sich, das Muster „ Vorlagenmethode “ in Betracht zu ziehen. Das Muster ist schon aus dem Namen ersichtlich. Die Quintessenz ist, dass der Code so geschrieben ist, dass den Benutzern des Codes (Entwicklern) eine Algorithmusvorlage zur Verfügung gestellt wird, deren Schritte neu definiert werden dürfen. Dadurch können Codebenutzer nicht den gesamten Algorithmus schreiben, sondern nur darüber nachdenken, wie sie den einen oder anderen Schritt dieses Algorithmus korrekt ausführen. Beispielsweise verfügt Java über eine abstrakte Klasse AbstractList, die das Verhalten eines Iterators definiert List. Der Iterator selbst verwendet jedoch Blattmethoden wie: get, set, remove. Das Verhalten dieser Methoden wird vom Entwickler der Nachkommen bestimmt AbstractList. Somit AbstractListist der Iterator in - eine Vorlage für den Algorithmus zum Iterieren über ein Blatt. Und Entwickler bestimmter Implementierungen AbstractListändern das Verhalten dieser Iteration, indem sie das Verhalten bestimmter Schritte definieren. Das letzte Muster, das wir analysieren, ist das „ Snapshot “-Muster (Momento). Sein Wesen besteht darin, einen bestimmten Zustand eines Objekts zu bewahren und diesen Zustand wiederherzustellen. Das bekannteste Beispiel aus dem JDK ist die Objektserialisierung, d. h. java.io.Serializable. Schauen wir uns ein Beispiel an:
import java.io.*;
import java.util.*;
class Main {
public static void main(String[] args) throws IOException {
ArrayList<String> list = new ArrayList<>();
list.add("test");
// Save State
ByteArrayOutputStream stream = new ByteArrayOutputStream();
try (ObjectOutputStream out = new ObjectOutputStream(stream)) {
out.writeObject(list);
}
// Load state
byte[] bytes = stream.toByteArray();
InputStream inputStream = new ByteArrayInputStream(bytes);
try (ObjectInputStream in = new ObjectInputStream(inputStream)) {
List<String> listNew = (List<String>) in.readObject();
System.out.println(listNew.get(0));
} catch (ClassNotFoundException e) {
// Do something. Can't find class fpr saved state
}
}
}
Abschluss
Wie wir im Test gesehen haben, gibt es eine große Vielfalt an Mustern. Jeder von ihnen löst sein eigenes Problem. Und die Kenntnis dieser Muster kann Ihnen helfen, rechtzeitig zu verstehen, wie Sie Ihr System so schreiben müssen, dass es flexibel, wartbar und resistent gegen Änderungen ist. Und zum Schluss noch ein paar Links für einen tieferen Einblick:- Die erstaunlichste Ressource für Muster: refactoring.guru
- Video-Playlist „ Entwurfsmuster in der objektorientierten Programmierung “
- Übungen zu Entwurfsmustern
- Mustertest
- Musterkurse auf Udemy
- Musterkurs auf Coursera
GO TO FULL VERSION