Delphi Design Patterns GoF/Design Patterns GoF/Design Patterns GoF

[Delphi] Design Patterns GoF/Design Patterns GoF/Design Patterns GoF

[Delphi] Design Patterns GoF/Design Patterns GoF/Design Patterns GoF
[Delphi] Design Patterns GoF/Design Patterns GoF/Design Patterns GoF


Today's article marks the beginning of Behavioral design patterns . They are named after proposing and recommending solutions that involve interactions between objects, so that even if there is such interaction, they do not depend heavily on each other, that is, they are loosely coupled. The first of these very easy to understand standards is the Chain of Responsibility . Have you heard? No? Then follow the article! One of the most important assumptions in designing software architecture is to maintain low coupling and high cohesion . The first requirement refers to the elimination of strong dependencies between classes, while the second involves the sole responsibility of each class, responding to the principle called Single Responsibility . A loosely coupled, highly cohesive architecture, therefore, means that the classes are well delimited and each takes on only a unique function in the system. The Chain of Responsibility Design Pattern represents a solution for reducing dependencies between classes. The main purpose is to allow messages (or data) to navigate between different objects within a hierarchy (or chain) until one of them has the ability to assume it, or rather process it, but in one important detail: hierarchy, each object does not know the details of the other.

Sometimes an intermediary for coordinating messages and interactions between objects may seem like an appropriate solution to avoid heavy reliance on them. With Mediator , this solution is feasible. In this article, we will look at the concept, purpose, and practical application of this design pattern, but I will be clear beforehand: Mediator is very easy to understand.

The structure of this design pattern is easy to understand, consisting of only four elements:  Mediator: Interface that defines the communication methods between objects;  Concrete Mediator: Concrete class that implements the Mediator Interface ;  Colleague: Interface that defines the methods referring to the “intentions” of objects;  Concrete Colleague: Concrete class that implements the Interface Colleage .

Over 20 years ago the iconic computer science book “Design Patterns: Elements of Reusable Object-Oriented Software” was first published. The four authors of the book: Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, have since been dubbed “The Gang of Four”. In technology circles, you’ll often see this nicknamed shorted to GoF. Even though the GoF Design Patterns book was published over 20 years ago, it still continues to be an Amazon best seller.

The GoF wrote the book in a C++ context but it still remains very relevant to Java programming. C++ and Java are both object-oriented languages. The GoF authors, through their experience in coding large scale enterprise systems using C++, saw common patterns emerge. These design patterns are not unique to C++. The design patterns can be applied in any object oriented language.

As a Java developer using the Spring Framework to develop enterprise class applications, you will encounter the GoF Design Patterns on a daily basis.

The GoF Design Patterns are broken into three categories: Creational Patterns for the creation of objects; Structural Patterns to provide relationship between objects; and finally, Behavioral Patterns to help define how objects interact.

Gang of Four Design Patterns
Creational Design Patterns
Abstract Factory. Allows the creation of objects without specifying their concrete type.
Builder. Uses to create complex objects.
Factory Method. Creates objects without specifying the exact class to create.
Prototype. Creates a new object from an existing object.
Singleton. Ensures only one instance of an object is created.
Structural Design Patterns
Adapter. Allows for two incompatible classes to work together by wrapping an interface around one of the existing classes.
Bridge. Decouples an abstraction so two classes can vary independently.
Composite. Takes a group of objects into a single object.
Decorator. Allows for an object’s behavior to be extended dynamically at run time.
Facade. Provides a simple interface to a more complex underlying object.
Flyweight. Reduces the cost of complex object models.
Proxy. Provides a placeholder interface to an underlying object to control access, reduce cost, or reduce complexity.
Behavior Design Patterns
Chain of Responsibility. Delegates commands to a chain of processing objects.
Command. Creates objects which encapsulate actions and parameters.
Interpreter. Implements a specialized language.
Iterator. Accesses the elements of an object sequentially without exposing its underlying representation.
Mediator. Allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
Memento. Provides the ability to restore an object to its previous state.
Observer. Is a publish/subscribe pattern which allows a number of observer objects to see an event.
State. Allows an object to alter its behavior when its internal state changes.
Strategy. Allows one of a family of algorithms to be selected on-the-fly at run-time.
Template Method. Defines the skeleton of an algorithm as an abstract class, allowing its sub-classes to provide concrete behavior.
Visitor. Separates an algorithm from an object structure by moving the hierarchy of methods into one object.

Only for V.I.P
Warning! You are not allowed to view this text.
Information
Users of Guests are not allowed to comment this publication.