Design Pattern

Zusammenfassung von Design Pattern in JAVA

Zusammenfassung von Design Pattern in JAVA


Kartei Details

Karten 33
Lernende 12
Sprache English
Kategorie Informatik
Stufe Universität
Erstellt / Aktualisiert 29.05.2013 / 28.01.2023
Weblink
https://card2brain.ch/box/design_pattern
Einbinden
<iframe src="https://card2brain.ch/box/design_pattern/embed" width="780" height="150" scrolling="no" frameborder="0"></iframe>

Basics

  • abstraction
  • encapsulation
  • polymorphism
  • inheritance

Principles

  • Encapsulate what varies
  • Favor composition over inheritance
  • Program to interface, not implementations
  • Strive for loosely coupled designs between objects that interact
  • Classes should be open for extension but closed for modification

Strategy Pattern

Stragety - defines a family of algorthms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

Good OO desings are:

  • reusable
  • extensible
  • maintainable

Patterns -generic

  • show you how to buld systems with good OO design qualities
  • are proven object-oriented experience
  • don't give xou code, they give you general solutions to design problems. You apply them to your specific application.
  • aren't invented they are discovered
  • provide a shared language that can maximize the value of your communication with other developers

Observer

Observer - defines a onte-to-many dependency between objects so that when one object change state, all its dependents are notified and updated automatically

Subjects

Subjects, or as we also know them, Observables, update Observers using a common interface

Observers

Observers are loosely coupled in that the Observable knows nothing about them, other than that they implement the Observer Interface

Decorater Pattern

Decorater - Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.

Principle no.1

Encapsulate what varies

principle no.2

Favor composition over inheritance

Principle no.3

Program to interface, not implementations

Principle no.4

Strive for loosely coupled designs between objects that interact

Principle no.5

Classes should be open for extension but closed for modification

Principle no.6

Depend on abstractions. Do not depend on concrete classes

Factory Method

Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to the subclasses.

Abstract Factory

Provide an interface for creating families of related or depedent objects without specifying their concrete classes.

Singleton

Ensure a class only has one instance and provide a global point of access to it

Singleton - Java implementation

  • private constructor
  • static method combined with
  • a static variable

Erzeugungsmuster

  • Fabrikmethode (klassenbasiert)
  • Abstrakte Fabrik
  • Erbauer
  • Prototyp
  • Singleton

Strukturmuster

  • Adapter (klassenbasiert)
  • Adapter (objektbasiert)
  • Brücke
  • Fassade
  • Fliegengewicht
  • Kompositum
  • Proxy

Verhaltensmuster

  • Interpreter (klassenbasiert)
  • Schablonenmethode (klassenbasiert)
  • Befehl
  • Beobachter
  • Besucher
  • Iterator
  • Memento
  • Strategie
  • Vermittler
  • Zustand
  • Zuständigkeitskette

Strategie Muster

Definiert eine Familie von Algorithmen, kapselt jeden einzelnen und macht sie austauschbar. Das Stategiemuster ermöglicht es, den Algorithmus unabhängig von ihn nutzenden Klienten zu variieren.

Beobachter Muster

Definiert eine 1-zu-n-Abhängigkeit zwischen Objekten, so dass die Änderung des Zustands eines Objekts dazu führt, dass alle abhängigen Objekte benachrichtgt werden.

Fabrikmethode

Definiert eine Klassenschnittstelle mit Operationen zum Erzeugen eines Objektes lässt aber Unterklassen entscheiden, von welcher Klasse das zu erzuegende Objekt ist.

Abstrakte Fabrik

Bietet eine Schnittstelle zum Erzeugen von Familien verwandter oder voneinander abhängiger Objekte an, ohne ihre konkreten Klasssen zu benennen.

Strategie Muster (Anwendungsbeispiele)

  • In Eingabemaksen kann die Logik zur Validierung und Plausibilitätsprüfung von Benutzereingaben gekapselt werden
  • Entkopplung von Verhatlen und Context, bei unterschiedlichen Ausformungen ein und der selben Funktion
    • Sortierung einer Collection (unterschiedliche Sortieralgos)
    • Speicherung in verschiedenen Dateiformaten
    • PAcker mit versch. Kompresssionsalgorithmen

Vorteile des Strategie Musters

  • Alternative zur Unterklassenbildung
  • Wiederverwendbarkeit und Entkoppelung von Context und Verhalten
  • Komposition statt Vererbung und Code Recycling (Durch Verebung entsteht evt. redundanter Code; Wartung und Erweiterung aufwändig)
  • dynamisches Vehalten (Setter zur Laufzeit können Verhalten ändern)
  • Vermeidung von Bedingungen. Keine Klassen mit verschiedenen Algos, die mit if - else Bedingungen ausgewählt werden. Steigerung der Kohäsion

Anwendungsbeispiele des Observer Patterns

  • GUI
  • Zeituhr, aktualisierung einer Digital- oder Analoguhr bei jedem Sekundentakt

Vorteile des Observer Pattern

  • Zustandkonsistenz
    • Kopplung zwischen den Objekten nur auf Zeit zwischen An- und Abmelden beschränkt
  • Flexibilität und Modularität
    • Registrierung / Auflösen von Observern zur Laufzeit
    • mehrer Observer beobachten ein Subject
    • ein Observer beobachtet mehrere Subjects
    • Klassen können sowohl Observer als auch Subject sein
  • Wiederverwendbarkeit
    • Observer und Subject lassen sich unabhängig voneinander variieren
  • Kompatibilität zum Schichtenmodell

Anwendungsbeispiele Obsserverpatterns

  • zur dynamischen und transparenten Funktionserweiterung von Objekten
  • zum Hinzufügen, aber auch Entfernen von Funktionalitäten
  • Kaffeebeispiel (3 Kaffeegrundsorten [Espersseo, Cappucino, Latte] und optionale Zusätze [Milch, Schoko, Sahne, Zucker])
  • Gericht mit Beilagen

Vorteile von Obsserverpatterns

  • Dynamik und Flexibilität
  • Vermeidung von langen unübersichtlichen Vererbungshierachien
  • Transparenz
  • Performance
  • Wartbarkeit durch schlanke, khäsive Klassen

Nachteile von Obsserverpatterns

  • Erschwerte Fehlerfindung
  • Hohe Objektanzahl