GRASP: General Responsibility Assignment Software Patterns (9 types in total)
Tell us how to design the classes in the problem space and assign their behavioral responsibilities, and clarify the interrelationships between classes, etc.
- Infomation Expert
- Creator _
- Low coupling (low coupling)
- High cohesion (high cohesion)
- Controller _
- Polymorphism
- Pure Fabrication
- Indirection
- Protected Variations
SOLID: Design principles (5 types in total)
- Single Responsibility Principle ( SRP )
- Open Closed Principle ( OCP )
- Liskov Substitution Principle ( LSP )
- Interface Segregation Principle ( ISP )
- Dependency Inversion Principle ( DIP )
GOF: Design Patterns (23 in total)
- Singleton mode: A class can only generate one instance, which provides a global access point for external access to the instance, and its extension is the limited multiple instance mode.
- Prototype mode: use an object as a prototype, and clone multiple new instances similar to the prototype by copying it.
- Factory Method (Factory Method) mode: Define an interface for creating products, and subclasses decide what products to produce.
- Abstract Factory (AbstractFactory) mode: Provide an interface to create a product family, each of its subclasses can produce a series of related products.
- Builder (Builder) mode: decompose a complex object into multiple relatively simple parts, then create them separately according to different needs, and finally build the complex object.
- Proxy mode: Provide a proxy for an object to control access to the object. That is, the client accesses the object indirectly through the proxy, thereby restricting, enhancing or modifying some characteristics of the object.
- Adapter (Adapter) mode: convert the interface of a class into another interface that the customer wants, so that those classes that could not work together due to interface incompatibility can work together.
- Bridge pattern: Separates abstraction from implementation so that they can vary independently. It is implemented by replacing the inheritance relationship with the composition relationship, thereby reducing the coupling degree of the two variable dimensions of abstraction and implementation.
- Decorator mode: Dynamically add some responsibilities to the object, that is, add its additional functions.
- Facade mode: Provide a consistent interface for multiple complex subsystems, making these subsystems easier to access.
- Flyweight mode: Use sharing technology to effectively support the reuse of a large number of fine-grained objects.
- Composite mode: Composes objects into a tree-like hierarchy, enabling users to have consistent access to individual objects and composite objects.
- Template Method (TemplateMethod) mode: define the algorithm skeleton in an operation, and delay some steps of the algorithm to the subclass, so that the subclass can redefine some specific steps of the algorithm without changing the structure of the algorithm.
- Strategy (Strategy) mode: defines a series of algorithms and encapsulates each algorithm so that they can be replaced with each other, and the change of the algorithm will not affect the customers who use the algorithm.
- Command mode: Encapsulate a request as an object, so that the responsibility for issuing the request is separated from the responsibility for executing the request.
- Chain of Responsibility (Chain of Responsibility) pattern: The request is passed from one object in the chain to the next object until the request is responded to. In this way the coupling between objects is removed.
- State (State) pattern: Allows an object to change its behavior when its internal state changes.
- Observer (Observer) mode: There is a one-to-many relationship between multiple objects. When an object changes, it notifies other multiple objects of this change, thereby affecting the behavior of other objects.
- Mediator mode: Define an intermediary object to simplify the interaction relationship between original objects, reduce the coupling degree between objects in the system, and make the original objects do not need to understand each other.
- Iterator mode: Provides a way to sequentially access a series of data in an aggregate object without exposing the internal representation of the aggregate object.
- Visitor mode: Provide multiple access methods for each element in a collection without changing the collection elements, that is, each element has multiple visitor objects to visit.
- Memento pattern: Get and save an object's internal state so that it can be restored later without breaking encapsulation.
- Interpreter (Interpreter) mode: Provides how to define the grammar of the language, and the method of interpreting language sentences, that is, the interpreter.
Other essential design principles:
① DRY - Don't Repeat Yourself
Don't repeat yourself: Try to reduce repeated lines of code, repeated methods, and repeated modules in the project.
② KISS - Keep It Simple & Stupid
Keep it simple and easy to understand: realize complex things "simplely". We should work on code comprehensibility, reduce complexity, and make maintenance easy.
"Any idiot can write a program that a computer can understand, but a good programmer is only one who can write a program that a human can easily understand."
③ YAGNI - You Ain't Gonna Need It
You will not need it: Do not over-design. The cost of design is very high. This kind of over-design will not only delay the speed of development iterations, but also its benefits are very low.
④ LOD - Law of Demeter
Dimiter's law: the principle of minimum knowledge. An object should have the least understanding of other objects. In layman's terms, the less a class knows about the classes it depends on, the better. That is, the methods that are exposed to the outside world should be as few as possible for the dependent classes.
reference:
Various design patterns explain the website
Understanding of the three principles of DRY, KISS, and YAGNI