Introduction to Design Patterns

What is GOF (full name: Gang of Four)?

In 1994 year, by Erich Gamma、Richard Helm、Ralph Johnson and John Vlissides four人combine著出editionalreadyonebooknameisDesign Patterns - Elements of Reusable Object-Oriented Software（ChinesetranslateFirst name:Design Patterns - ReusableofObject-Oriented软件element）the book, which was the first to mention the concept of design patterns in software development.

Gang of FourGOF (full spelling: Gang of Four)The design patterns they proposed are mainly based on the following object-oriented design principles.

• Program to an interface, not to an implementation.
• Favor object composition over inheritance.

Use of Design Patterns

Two main uses of design patterns in software development.

A common platform for developers

Design patterns provide a standard terminology system, specific to particular scenarios. For example, the Singleton design pattern means using a single object, so that all developers familiar with the Singleton design pattern can use a single object, and in this way can tell others that the program uses the Singleton pattern.

Best practice

Design patterns have undergone a long period of development, and they provide the best solutions to general problems faced in the software development process. Learning these patterns helps less experienced developers learn software design in a simple and quick way.

Types of Design Patterns

According to the design patterns reference bookDesign Patterns - Elements of Reusable Object-Oriented Software（ChinesetranslateFirst name:Design Patterns - ReusableofObject-Oriented软件element）As mentioned, there are a total of 23 design patterns. These patterns can be divided into three major categories: Creational Patterns, Structural Patterns, and Behavioral Patterns. Of course, we will also discuss another category of design patterns: J2EE design patterns.

Serial Number	Patterns & Descriptions	including
1	Creational pattern These design patterns provide a way to hide creation logic while creating objects, rather than using the new operator to directly instantiate objects. This makes the program more flexible in determining which objects need to be created for a given instance.	Factory Pattern（Factory Pattern） Abstract Factory Pattern Singleton Pattern Builder Pattern Prototype Pattern
2	Structural pattern These patterns focus on the composition and relationships between objects, aiming to solve how to build flexible and reusable class and object structures.	Adapter Pattern Bridge Pattern Filter Pattern (Filter, Criteria Pattern) Composite Pattern Decorator Pattern Facade Pattern Flyweight Pattern Proxy Pattern
3	Behavioral pattern These patterns focus on communication and interaction between objects, aiming to solve the assignment of responsibilities among objects and the encapsulation of algorithms.	Chain of Responsibility Pattern Command Pattern Interpreter Pattern Iterator Pattern Mediator Pattern Memento Pattern Observer Pattern State Pattern Null Object Pattern Strategy Pattern Template Pattern Visitor Pattern
4	J2EE Patterns These design patterns pay special attention to the presentation layer. These patterns were identified by Sun Java Center.	MVC Pattern Business Delegate Pattern Composite Entity Pattern Data Access Object Pattern Front Controller Pattern Intercepting Filter Pattern Service Locator Pattern Transfer Object Pattern

Below, an image is used to describe the relationships among design patterns as a whole:

Advantages of Design Patterns

• Provides a shared design vocabulary and concepts, enabling developers to better communicate and understand each other's design intentions.
• Provides proven solutions that can improve software maintainability, reusability, and flexibility.
• Promotes code reuse, avoiding duplicate design and implementation.
• By following design patterns, errors and problems in the system can be reduced, and code quality can be improved.

The Six Principles of Design Patterns

1. Open Close Principle

The Open-Closed Principle means:Open for extension, closed for modificationWhen the program needs to be extended, the original code must not be modified, achieving a hot-swappable effect. In short, it is to make the program highly extensible and easy to maintain and upgrade. To achieve this effect, we need to use interfaces and abstract classes, which we will mention in the later specific design.

2. Liskov Substitution Principle

The Liskov Substitution Principle is one of the basic principles of object-oriented design. The Liskov Substitution Principle states that wherever a base class can appear, a subclass must be able to appear as well. LSP is the cornerstone of inheritance and reuse. Only when a derived class can replace the base class without affecting the functionality of the software unit can the base class truly be reused, and the derived class can also add new behaviors on the basis of the base class. The Liskov Substitution Principle is a supplement to the Open-Closed Principle. The key step in implementing the Open-Closed Principle is abstraction, and the inheritance relationship between base classes and subclasses is the concrete implementation of abstraction. Therefore, the Liskov Substitution Principle is a specification of the concrete steps for implementing abstraction.

3. Dependency Inversion Principle

This principle is the foundation of the Open-Closed Principle. Specific content: program for interfaces, depend on abstraction rather than on concrete implementations.

4. Interface Segregation Principle (Interface Segregation Principle)

The meaning of this principle is: using multiple isolated interfaces is better than using a single interface. It also has another meaning: reduce the coupling between classes. From this, it can be seen that design patterns are actually software design ideas derived from large-scale software architecture, convenient for upgrading and maintenance, emphasizing the reduction of dependencies and coupling.

5. Demeter's Law, also known as the Least Knowledge Principle (Demeter Principle)

The Least Knowledge Principle means: an entity should interact with other entities as little as possible, so that system functional modules are relatively independent.

6. Composite Reuse Principle

The Composite Reuse Principle means: try to use composition/aggregation instead of inheritance.

other extensions