Learn design patterns one by one, and when you understand them, crumb them up, break them up, and then modify existing projects and think about which design patterns you can use.

The path to design patterns

• Familiarity stage, as if every design pattern is consistent with the current situation, different design patterns have ambiguity, similarities, and violations of design principles, seem to be able to solve. Don’t be afraid to pick the one that feels best for you.
• Use stage, will be a variety of design mode mixed use, the whole clearly, but the design will be a little stiff, lack of flexibility
• The design pattern is rotten and in my heart. When writing code, I naturally use my own pattern for a long time. According to the seven principles of design pattern, I write excellent code
• Magically, the design principles are already in your subconscious mind, and you are already experimenting with new principles.

Just like When Zhang Wuji learned tai chi with Zhang Sanfeng, all the learning is the entrance; Forget it all, and then you’re in a good place. It’s still a long way from being a god.

List of design pattern principles

• The open and closed principle is the general principle. It tells us to be open to expansion and closed to modification.
• Richter’s substitution tells us not to break the inheritance system;
• The dependency inversion principle tells us to program for interfaces;
• The single responsibility principle tells us to implement a class with a single responsibility;
• The principle of interface isolation tells us to keep interfaces simple and simple when designing them.
• Demeter’s rule tells us to reduce coupling;
• The principle of composite reuse tells us to use composite or aggregate relation reuse in preference to inheritance relation reuse.

schedule

The name of the	classification	thought	role	The sample
Simple Factory model	Create a type	Use a factory to create the same kind of thing required	Concrete factory class, Abstract object class, concrete object class	Factory produces round, square, oval and diamond buttons
Factory method pattern	Create a type	Use one factory to create the same kind of thing with multiple requirements	Concrete factory class, Abstract object class, concrete object class	The Factory produces round, square, oval, and diamond buttons, and differentiates between dark theme and normal mode
Abstract Factory pattern	Create a type	Use a factory to create different kinds of things with multiple requirements	Abstract factory, factory, abstract product variety, concrete product variety	Factory produces round, square, oval, diamond controls, while distinguishing between dark theme, or normal mode; Controls include buttons, UILabel, UIView, UIImageView
Builder model	Create a type	Create a complex thing	The commander, the abstract builder, the concrete builder, the built object	Learn builder mode by ordering in KFC
The singleton pattern	Create a type	Single, repeated, frequent use	x	XXManager,XXServer,UserDefault
=	=	=	=	=
Adapter mode	structured	Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee Adaptee	Adaptee, Adapter, Target	Learn adapter patterns by scrolling through a diagram
The bridge model	structured	When A wants to use B but cannot do so through inheritance and combination	Bridge files, which should be extremely complicated black boxes	Apple provides the idea of using Bridges, one is native OC, Swift calls JS, another is Swift calls OC; One example I can think of: We use Swift to parse Lottie’s JSON file ourselves, and then modify the values inside to animate, change width, height, and color
Decorator mode	structured	Add methods to objects dynamically	x	Protocol oriented programming in SWIFT and Extension share this idea
The appearance model	structured	Reduce interaction between different classes and provide a unified interface	User, appearance, sub-function	In fetching a resource class, you need to call the local cache and network data respectively, and finally return the combined result. Implementing isolation reduces interaction between classes
The proxy pattern	structured	Occupy pit first, asynchronous operation	x	Time-consuming operation, images load asynchronously
The flyweight pattern	structured	Caching systems that cache in memory and reuse a lot are good for things with less granularity	x	x
=	=	=	=	=
Command mode (×)	Behavior type	Abstract commands into objects, concrete command objects that provide interfaces to the outside world and are responsible for the execution of commands	Abstract command class, concrete command class, caller, receiver	Design Mode Series 6– Command mode
The mediator pattern	Behavior type	By encapsulating a set of object interactions with a mediation object, the mediator loosens the coupling of objects without explicitly referring to each other, and can change their interactions independently	Mediator: ConcreteMediator, Colleague: ConcreteColleague	Design Patterns Series 3– Mediator patterns
Observer model	Behavior type	Active observation of state changes, resulting in changes, one-to-many scenarios	Abstract target, target, abstract observer, observer	KVO, Notification,
The state pattern	Behavior type	The behavior of an object depends on its State. An environment class is actually an object that owns State. An environment class can sometimes act as a State Manager in which you can switch states	Environment class, Abstract state class, concrete state class	Design Patterns Series 9– State patterns.
The strategy pattern	Behavior type	Define a set of algorithms, encapsulate them one by one, and make them interchangeable. The policy pattern allows the algorithm to change independently of the clients that use it	Environment class, Abstract policy class, concrete policy class	X module has A piecewise function, X module is required for A, B, C, but have different requirements of piecewise function in X module, at this time, you can write the if and else statements in X module, or A switch statement, but this violation of the principle of opening and closing, so the better way is to put the function algorithm is used to encapsulate, passed as A parameter to enter.

Creation pattern

• The creative pattern gives the software designer as much flexibility as possible in What to create, Who to create, and When to create.

• The creation pattern hides the creation details of instances of classes, making the whole system independent by hiding how objects are created and grouped together.

• Description: The mode to use when creating objects

• Keywords: Build, build, construct, create, factory mode

1. Simple factory model

• Scenario: Producing a single type of product
• Roles: factory, abstract product, concrete product
• See Factory Mode three Brothers

Ii. Factory design mode

• Scenario: Production of a single type of product (large quantity, distributed to different factories)
• Roles: Abstract factory, factory, abstract product, concrete product
• See Factory Mode three Brothers

Abstract factory model

• Scenario: Production of multiple types of products (in large quantities, distributed to different factories)
• Role: Abstract factory, factory, abstract product variety, concrete product variety
• See Factory Mode three Brothers

Fourth, the builder model

• Learn builder mode by ordering in KFC

5. Singleton mode

• Scenario: single, repeated, frequent use
• Note: Some resources are released when they are no longer needed, or when a memory warning is received
• Example: XXManager XXServer, UserDefault

Structural mode

• Description: when a function is more complex, how can it be reused and combined to form a complex and more powerful structure
• Keywords: frame, decoupling, isolation, composition, structure
• Structural patterns can be divided into class structural patterns and object structural patterns
  • The class-structured pattern is concerned with the composition of classes, from which multiple classes can be combined into a larger one
  • The object structural pattern is concerned with the composition of classes and objects by associating them so that an instance object of another class is defined in one class and its methods are called through that object. According to the principle of composite reuse, relational relationships are used instead of inheritance relationships in the system, so most structural patterns are object structural patterns.

Adapter mode

• Adaptation, reference UITableViewdelegate, UITableViewDataSource
• Example: Learn adapter patterns by scrolling through a diagram

Second, bridge mode

• When A wants to use B but cannot do so through inheritance and combination
• Bridge files, which should be extremely complicated black boxes
• Apple provides the idea of using Bridges, one is native OC, Swift calls JS, another is Swift calls OC;
• One example I can think of: We use Swift to parse Lottie’s JSON file ourselves, and then modify the values inside to animate, change width, height, and color

Decorator mode

• Dynamic extension methods, functions
• Example: Protocol oriented programming in Swift and Extension share this idea

4. Appearance mode

• Description: Reduce the interaction between different classes, provide a unified interface

• Example: For example, in obtaining resource classes, local cache and network data need to be called to achieve isolation and reduce interaction between different classes

• Code: https://www.raywenderlich.com/477-design-patterns-on-ios-using-swift-part-1-2#toc-anchor-007

5. Agency mode

• Description: Occupy pit first, after operation
• Example: Time-consuming operation, image load asynchronously

Six, enjoy yuan mode

• Cache system, cache in memory, a lot of repeated use for smaller particles
• Example: Unknown

Behavioral pattern

• Note: By communicating and collaborating with each other to perform some complex functions, one object at run time will also affect the operation of other objects

• Keywords: observation, notification, MVC, feedback, monitoring

• Behavioral pattern can be divided into class behavior pattern and object behavior pattern:

  • Class behavior pattern: The behavior pattern of a class uses inheritance relationships to distribute behavior among several classes. Class behavior pattern mainly distributes responsibilities of parent and subclass by means of polymorphism.
  • Object behavior pattern: The object behavior pattern uses the aggregate association of objects to assign behaviors. The object behavior pattern mainly assigns responsibilities of two or more classes through object association. According to the principle of composite reuse, association relation should be used to replace inheritance relation, so most behavior design pattern belongs to object behavior design pattern.

First, command mode

• Abstract the command into an object, the specific command object, to provide interface to the outside world, while responsible for the execution of the command
• Example: Design Mode Series 6– Command mode

Second, the intermediary model

• Note: A and B do not communicate with each other, but communicate through C.
• Example: For example, the Model and View in MVC do not communicate directly, but communicate through Controller; In real life, intermediary companies do just this job, and controllers deal with too many things, which will become more and more complicated and bloated. The disadvantages of this mode are also the same.
• Design Patterns Series 3– Mediator patterns

Observer model

• Description: Active observation of state change, thus change
• Examples are KVO and Notification

4. State mode

• Description: Allows an object to change its behavior when its internal state changes. Object appears to have modified its class.
• Example: Design Patterns Series 9– State patterns
• Personal understanding: If in different states, there may be the same operation, then the state is encapsulated into a class, the operation is defined as a protocol, each state class comply with this protocol, and implementation.

5. Strategic mode

• Description: define a series of algorithms, encapsulate them one by one, and make them interchangeable. The policy pattern allows the algorithm to change independently of the clients that use it.
• Example 1: Design Patterns Series 8– Policy patterns
• Example 2: X module has A piecewise function, X module is required for A, B, C, but have different requirements of piecewise function in X module, at this time, you can write the if and else statements in X module, or A switch statement, but this violation of the principle of opening and closing, so the better way is to put the function algorithm is used to encapsulate, passed as A parameter to enter.

Reference links:

• https://juejin.cn/post/6844903934230806535
• https://design-patterns.readthedocs.io/zh_CN/latest/index.html
• https://juejin.cn/user/3526889030556574

This article is formatted using MDNICE