A collection of the most popular design pattern tutorials made by INTEGU. The tutorials include everything from theory, practical examples, videoes, class diagram, and code snippets.
The composite design pattern is intended for structuring data classes with a relationship to each other. It categorizes the data as either a composite- or and leaf class, which determines whether other classes can be stored within the class. For this reason, it should come as no shock that it is a structural design pattern.
The Facade Pattern is based on the concept of simplifying activities. It allows us to wrap complex procedures in a facade class and afterwards utilize these procedures by one simple method call. For this reason it is categorized as a structural design pattern.
The Adapter Pattern is a simple, yet convenient, utility, which you will most certainly find good use of.
The pattern uses and interface and its implementation to create a layer around another object, which then allows the behavior of the object to be converted into a desired form.
The Command Pattern uses an object to represent a method (aka command), which can be call upon later by an invoker. This means that it will be possible to send methods around the system and call upon them whenever they are needed.
The Singleton Pattern is without a doubt the simplest, but also most powerful design patterns. It provides a one-way access to a class, which ensures that whenever this class is retrieved, that it will always be the same instance.
The Visitor Pattern allows you to add new methods to other classes without creating major changes. Additionally, these methods can be customized to match the desired functionality for the object for which it is added to.
The Builder Pattern helps separating the construction of complex objects from the context where they are needed. Additionally, the pattern also contains different variations of objects which have a common construction procedure.
This makes the builder pattern convenient to use when complex objects needs to be created and well aligned with the Single Responsibility Principle. (SRP)
Given that the builder pattern sets up a method for constructing new objects, it is understandably categorized as a creational design pattern.
The reasoning for using the Decorator Pattern is to obtain the advantages of class inheritance within a dynamic context. (aka. at runtime.) This allow objects to add and remove additional features while the program is running instead of specifically declaring it when the program compiles.
As arguably the most popular creational design pattern, the factory pattern provides guidelines for how to flexibly and conveniently create different objects with the same method, by only changing the method’s argument. Utilizing the factory pattern in the creation of objects allows all complexities of the creation to be hidden away. Simultaneously the factory can be designed to create any variation of an object, as long as all objects extend from the same super-class.
The Observer Pattern is a frequently used and very practical design pattern. Mastering this pattern will probably be a great help for any developer. As a behavioral pattern, the observer pattern provides one object with a loosely couple method of informing multiple objects of property changes.
INTEGU uses cookies to personalize your experience and provide traceability for affiliate links. By using the website, you agree to these terms and conditions. To learn more see the privacy policy page.
