|

Object Pool

We will learn how to control the number of simultaneous processes, optimizing system resources and avoiding system overload due to process saturation.

Iterator

Through the implementation of the Iterator design pattern, we will create an application that allows us to go through a hierarchical organizational structure, through the implementation of an iterator, which will allow us to go through the entire structure tree sequentially.

Command

Build your own command line console using the Command design pattern, since this pattern allows us to create small components that can be simply executed with the help of a simple terminal.

Observer

By implementing the Observer design pattern we will develop an application that loads the system configuration from the beginning. Said configuration will automatically notify all the objects that are interested in the changes, all this in order that the objects interested in the configuration do not have to consult each moment if there is any important change to reflect it to the user.

Template Method

The template design pattern focuses its functionality on code reuse and is used to implement algorithms that perform the same steps to arrive at a solution. This is achieved by implementing base classes that define default behavior. Usually a method is created for each step of the algorithm to be implemented, some of which will be implemented and others will remain abstract until executed by subclasses.

Strategy

We will learn to create applications that allow multiple forms of user authentication, through the construction of strategies, for authentication by Database, XML files, memory or any other.

Chain of Responsability

The Chain of Responsibility design pattern is a pattern that stands out for its versatility, allowing us to solve problems where we are not very sure which object should process a specific request; this design pattern easily solves problems where inheritance cannot.

Interpreter

We will build an interpreter that allows us to execute SQL queries on an Excel file, we will use the Sheets as Tables and the columns of the sheets as Columns of tables. All this using the Interpreter pattern.

Mediator

Through the Mediator pattern, we will develop a Modular application, which will allow the modules to communicate with each other, through a central component which will mediate the requests to deliver them to the appropriate module.

Memento

Memento is a designed pattern that allows us to capture the state of an object at a given moment in order to return to this state at any time. This pattern is used when we have objects that change over time and for some reason we need to restore their state at a certain time.

Null Object

The Null Object design pattern arises from the need to avoid null values that can cause errors at runtime. Basically what this pattern proposes is to use instances that implement the required interface but with an empty body instead of returning a null value.

State

Learn to manage the life cycle of a server by implementing a state machine, which will allow us to start, prepare and shut down our own server.

Visitor

Through the implementation of the Visitor design pattern, we will see how the construction plan of a Microsoft Project type project is analyzed and evaluated to provide the data that we require from it, for this, we will build a work plan made up of activities and personnel, form a hierarchical tree-like structure.