Design Patterns

Name: Design Patterns | Entwurfsmuster als Elemente wiederverwendbarer objektorientierter Software
Brand: MITP
Price: 39.99 EUR
Availability: OnlineOnly

Entwurfsmuster als Elemente wiederverwendbarer objektorientierter Software

Erich Gamma Richard Helm Ralph Johnson John M. Vlissides(Autor*in)

MITP (Verlag)

1. Auflage

Erschienen am 26. Januar 2015

480 Seiten

E-Book

PDF ohne DRM

Systemvoraussetzungen

978-3-8266-9903-0 (ISBN)

39,99 €inkl. 7% MwSt.

Systemvoraussetzungen

für PDF ohne DRM

E-Book Einzellizenz

Als Download verfügbar

Beschreibung

Der Bestseller von Gamma und Co. in komplett neuer Übersetzung
Das Standardwerk für die objektorientierte Softwareentwicklung
Zeitlose und effektive Lösungen für wiederkehrende Aufgaben im Softwaredesign

Mit Design Patterns lassen sich wiederkehrende Aufgaben in der objektorientierten Softwareentwicklung effektiv lösen. Die Autoren stellen einen Katalog einfacher und prägnanter Lösungen für häufig auftretende Aufgabenstellungen vor. Mit diesen 23 Patterns können Softwareentwickler flexiblere, elegantere und vor allem auch wiederverwendbare Designs erstellen, ohne die Lösungen jedes Mal aufs Neue selbst entwickeln zu müssen.

Die Autoren beschreiben zunächst, was Patterns eigentlich sind und wie sie sich beim Design objektorientierter Software einsetzen lassen. Danach werden die stets wiederkehrenden Designs systematisch benannt, erläutert, beurteilt und katalogisiert. Mit diesem Leitfaden lernen Sie, wie sich diese wichtigen Patterns in den Softwareentwicklungsprozess einfügen und wie sie zur Lösung Ihrer eigenen Designprobleme am besten eingesetzt werden.

Bei jedem Pattern ist angegeben, in welchem Kontext es besonders geeignet ist und welche Konsequenzen und Kompromisse sich aus der Verwendung des Patterns im Rahmen des Gesamtdesigns ergeben. Sämtliche Patterns entstammen echten Anwendungen und beruhen auf tatsächlich existierenden Vorbildern. Außerdem ist jedes Pattern mit Codebeispielen versehen, die demonstrieren, wie es in objektorientierten Programmiersprachen wie C++ oder Smalltalk implementiert werden kann.
Das Buch eignet sich nicht nur als Lehrbuch, sondern auch hervorragend als Nachschlagewerk und Referenz und erleichtert so auch besonders die Zusammenarbeit im Team.

Aus dem Inhalt:
Einführung
Fallstudie
Erzeugungsmuster
Abstract Factory
Builder
Factory Method
Prototype
Singleton
Strukturmuster
Adapter
Bridge
Composite
Decorator
Facade
Flyweight
Proxy
Verhaltensmuster
Chain of Responsibility
Command
Interpreter
Iterator
Mediator
Memento
Observer
State
Strategy
Template Method
Visitor

Stimmen zum Buch:
»Für Designer und Entwickler objektorientierter Software ist dieses Buch von großer Bedeutung! Design Patterns stellt einen geordneten Katalog bewährter Entwurfsmus-ter zur Strukturierung, Erstellung und Manipulation von Objekten vor. Am wichtigsten ist jedoch, dass die verschiedenen Design Patterns eindeutige Bezeichnungen erhalten, die ein gemeinsames Vokabular für die Arbeit im Team bereitstellen.«
- Rebecca J. Wirfs-Brock, Director, Object-Technology Services, Digitalk

»Design Patterns beendet die Debatte um die Wiederverwendung von Code und zeigt das entscheidende Element der Wiederverwendbarkeit von Software auf: wiederverwendbares Design. Sie werden feststellen, dass Sie diese Patterns im Nu in Ihren eigenen Designs einsetzen und wiederverwenden.«
- Steve Vinoski, Software Architect

Weitere Details

Weitere Ausgaben

Personen

Inhalt

1 - Cover [Seite 1]
2 - Titel [Seite 11]
3 - Impressum [Seite 12]
4 - Inhaltsverzeichnis [Seite 15]
5 - Vorwort [Seite 19]
6 - Geleitwort von Grady Booch [Seite 23]
7 - Einleitung [Seite 25]
8 - Kapitel 1: Einführung [Seite 27]
8.1 - 1.1 Was ist ein Design Pattern? [Seite 29]
8.2 - 1.2 Design Patterns im Smalltalk MVC [Seite 32]
8.3 - 1.3 Beschreibung der Design Patterns [Seite 34]
8.4 - 1.4 Der Design-Patterns-Katalog [Seite 36]
8.5 - 1.5 Aufbau des Katalogs [Seite 40]
8.6 - 1.6 Die Anwendung von Design Patterns zur Behebung von Designproblemen [Seite 43]
8.6.1 - 1.6.1 Passende Objekte finden [Seite 43]
8.6.2 - 1.6.2 Objektgranularität bestimmen [Seite 44]
8.6.3 - 1.6.3 Objektschnittstellen spezifizieren [Seite 44]
8.6.4 - 1.6.4 Objektimplementierungen spezifizieren [Seite 46]
8.6.5 - 1.6.5 Wiederverwendungsmechanismen einsetzen [Seite 51]
8.6.6 - 1.6.6 Strukturen der Laufzeit und beim Kompilieren abstimmen [Seite 56]
8.6.7 - 1.6.7 Designänderungen berücksichtigen [Seite 58]
8.7 - 1.7 Auswahl eines Design Patterns [Seite 65]
8.8 - 1.8 Anwendung eines Design Patterns [Seite 67]
9 - Kapitel 2: Fallstudie: Erstellung eines Texteditors [Seite 69]
9.1 - 2.1 Designprobleme [Seite 69]
9.2 - 2.2 Dokumentstruktur [Seite 71]
9.2.1 - 2.2.1 Rekursive Komposition [Seite 73]
9.2.2 - 2.2.2 Glyphen [Seite 74]
9.2.3 - 2.2.3 Das Design Pattern Composite (Kompositum) [Seite 77]
9.3 - 2.3 Formatierung [Seite 78]
9.3.1 - 2.3.1 Kapselung des Formatierungsalgorithmus [Seite 78]
9.3.2 - 2.3.2 Die Unterklassen Compositor und Composition [Seite 79]
9.3.3 - 2.3.3 Das Design Pattern Strategy (Strategie) [Seite 81]
9.4 - 2.4 Ausgestaltung der Benutzeroberfläche [Seite 82]
9.4.1 - 2.4.1 Durchsichtige Umhüllung (Transparent Enclosure) [Seite 82]
9.4.2 - 2.4.2 Die Unterklasse MonoGlyph [Seite 84]
9.4.3 - 2.4.3 Das Design Pattern Decorator (Dekorierer) [Seite 86]
9.5 - 2.5 Unterstützung mehrerer Look-and-Feel-Standards [Seite 87]
9.5.1 - 2.5.1 Abstrahierung der Objekterzeugung [Seite 87]
9.5.2 - 2.5.2 Factories und Produktklassen [Seite 88]
9.5.3 - 2.5.3 Das Design Pattern Abstract Factory (Abstrakte Fabrik) [Seite 91]
9.6 - 2.6 Unterstützung mehrerer Fenstersysteme [Seite 92]
9.6.1 - 2.6.1 Eignung des Design Patterns Abstract Factory (Abstrakte Fabrik) [Seite 92]
9.6.2 - 2.6.2 Kapselung von Implementierungsabhängigkeiten [Seite 93]
9.6.3 - 2.6.3 Die Klassenhierarchien Window und WindowImp [Seite 95]
9.6.4 - 2.6.4 Das Design Pattern Bridge (Brücke) [Seite 99]
9.7 - 2.7 Userseitige Operationen [Seite 100]
9.7.1 - 2.7.1 Kapselung eines Requests [Seite 101]
9.7.2 - 2.7.2 Die Command-Klasse und ihre Unterklassen [Seite 102]
9.7.3 - 2.7.3 Die Funktion Undo (Rückgängig) [Seite 103]
9.7.4 - 2.7.4 Befehlshistorie [Seite 104]
9.7.5 - 2.7.5 Das Design Pattern Command (Befehl) [Seite 106]
9.8 - 2.8 Rechtschreibprüfung und Silbentrennung [Seite 107]
9.8.1 - 2.8.1 Zugriff auf verteilte Informationen [Seite 107]
9.8.2 - 2.8.2 Kapselung von Zugriff und Traversierung [Seite 108]
9.8.3 - 2.8.3 Die Iterator-Klasse und ihre Unterklassen [Seite 110]
9.8.4 - 2.8.4 Das Design Pattern Iterator (Iterator) [Seite 113]
9.8.5 - 2.8.5 Traversierung kontra Traversierungsaktionen [Seite 113]
9.8.6 - 2.8.6 Kapselung der Analyse [Seite 114]
9.8.7 - 2.8.7 Die Visitor-Klasse und ihre Unterklassen [Seite 119]
9.8.8 - 2.8.8 Das Design Pattern Visitor (Besucher) [Seite 120]
9.9 - 2.9 Zusammenfassung [Seite 121]
10 - Kapitel 3: Erzeugungsmuster (Creational Patterns) [Seite 125]
10.1 - 3.1 Abstract Factory (Abstrakte Fabrik) [Seite 130]
10.2 - 3.2 Builder (Erbauer) [Seite 141]
10.3 - 3.3 Factory Method (Fabrikmethode) [Seite 151]
10.4 - 3.4 Prototype (Prototyp) [Seite 163]
10.5 - 3.5 Singleton (Singleton) [Seite 174]
10.6 - 3.6 Weitere Erläuterungen zu den Erzeugungsmustern [Seite 183]
11 - Kapitel 4: Strukturmuster (Structural Patterns) [Seite 187]
11.1 - 4.1 Adapter (Adapter) [Seite 189]
11.2 - 4.2 Bridge (Brücke) [Seite 202]
11.3 - 4.3 Composite (Kompositum) [Seite 214]
11.4 - 4.4 Decorator (Dekorierer) [Seite 228]
11.5 - 4.5 Facade (Fassade) [Seite 239]
11.6 - 4.6 Flyweight (Fliegengewicht) [Seite 249]
11.7 - 4.7 Proxy (Proxy) [Seite 264]
11.8 - 4.8 Weitere Erläuterungen zu den Strukturmustern [Seite 277]
11.8.1 - 4.8.1 Adapter (Adapter, siehe Abschnitt 4.1) kontra Bridge (Brücke, siehe Abschnitt 4.2) [Seite 277]
11.8.2 - 4.8.2 Composite (Kompositum, siehe Abschnitt 4.3) kontra Decorator (Dekorierer, siehe Abschnitt 4.4) kontra Proxy (Proxy, siehe Abschnitt 4.7) [Seite 278]
12 - Kapitel 5: Verhaltensmuster (Behavioral Patterns) [Seite 281]
12.1 - 5.1 Chain of Responsibility (Zuständigkeitskette) [Seite 282]
12.2 - 5.2 Command (Befehl) [Seite 294]
12.3 - 5.3 Interpreter (Interpreter) [Seite 306]
12.4 - 5.4 Iterator (Iterator) [Seite 322]
12.5 - 5.5 Mediator (Vermittler) [Seite 340]
12.6 - 5.6 Memento (Memento) [Seite 351]
12.7 - 5.7 Observer (Beobachter) [Seite 362]
12.8 - 5.8 State (Zustand) [Seite 374]
12.9 - 5.9 Strategy (Strategie) [Seite 385]
12.10 - 5.10 Template Method (Schablonenmethode) [Seite 396]
12.11 - 5.11 Visitor (Besucher) [Seite 402]
12.12 - 5.12 Weitere Erläuterungen zu den Verhaltensmustern [Seite 419]
12.12.1 - 5.12.1 Variieren der Kapselung [Seite 419]
12.12.2 - 5.12.2 Objekte als Argumente [Seite 420]
12.12.3 - 5.12.3 Kommunikation: Kapseln oder Verteilen? [Seite 420]
12.12.4 - 5.12.4 Absender und Empfänger entkoppeln [Seite 421]
12.12.5 - 5.12.5 Zusammenfassung [Seite 424]
13 - Kapitel 6: Schlusswort der Autoren [Seite 427]
13.1 - 6.1 Was kann man von Design Patterns erwarten? [Seite 427]
13.1.1 - 6.1.1 Ein gemeinsames Designvokabular [Seite 428]
13.1.2 - 6.1.2 Eine Dokumentations- und Lernhilfe [Seite 428]
13.1.3 - 6.1.3 Eine Ergänzung zu existierenden Methoden [Seite 429]
13.1.4 - 6.1.4 Zielsetzungen für Refactorings [Seite 430]
13.2 - 6.2 Eine kleine Kataloggeschichte [Seite 432]
13.3 - 6.3 Die Pattern-Gemeinde [Seite 433]
13.3.1 - 6.3.1 Christopher Alexanders »Muster-Sprache« [Seite 434]
13.3.2 - 6.3.2 Patterns in Softwaresystemen [Seite 435]
13.4 - 6.4 Eine Einladung [Seite 436]
13.5 - 6.5 Ein abschließender Gedanke [Seite 437]
14 - Anhang A: Glossar [Seite 439]
15 - Anhang B: Notationshinweise [Seite 445]
15.1 - B.1 Klassendiagramme [Seite 446]
15.2 - B.2 Objektdiagramme [Seite 449]
15.3 - B.3 Interaktionsdiagramme [Seite 449]
16 - Anhang C: Fundamentale Klassen [Seite 451]
16.1 - C.1 Die Klasse List [Seite 451]
16.2 - C.2 Iterator [Seite 454]
16.3 - C.3 ListIterator [Seite 454]
16.4 - C.4 Point [Seite 455]
16.5 - C.5 Rect [Seite 456]
17 - Anhang D: Quellenverzeichnis [Seite 457]
18 - Stichwortverzeichnis [Seite 463]

Systemvoraussetzungen

Als PDF speichern Als Link merken