Introduction to Java Design patterns

1, what is the design mode

With regard to design patterns, there are some more official definitions, such as: Design pattern is a set of reusable, most known, categorized purposes, code design experience Summary. Design patterns are used in order to reuse code, make code easier for others to understand, and ensure code reliability. There is no doubt that design patterns in others in the system are multi-win, design patterns so that code is truly engineering, design patterns are the cornerstone of software engineering, like a block of bricks and tiles in the building.

The rational use of design patterns in the project can solve many problems perfectly, each of which has corresponding principles in the present, each of which describes a recurring problem around us, and the core solution of the problem, which is why it can be widely used.

In fact, according to this definition, we can get a very simple concept: the design pattern is to simplify the code, optimize the code structure, abstraction and encapsulation functions.

2. Design Pattern classification

In different application scenarios, different design patterns will be used, and in the long-term practice and summary, the design patterns will be summed up to some of the following:

In general, design patterns fall into three broad categories:
Create five types of models: Factory method mode, abstract Factory mode, singleton mode, builder mode, prototype mode.
Structure mode, a total of seven kinds: Adapter mode, adorner mode, proxy mode, appearance mode, bridging mode, combined mode, enjoy the meta-mode.
There are 11 types of behavioral Patterns: Strategy mode, template method mode, observer mode, iteration sub-mode, responsibility chain mode, Command mode, Memo mode, state mode, visitor mode, mediator mode, interpreter mode.

Give an illustration of the following:

3, six principles

The design pattern is to abstract the code, encapsulation and so on, then, how do we implement the encapsulation of the code? Under what circumstances is encapsulation carried out? What is the way to encapsulate it? In this way, some principles of code writing are derived, and according to experience, there are six principle problems.

3.1. Opening and closing principle (Open Close Principle)The open and closed principle is to say to the expansion opening, to modify the closure. When the program needs to expand, can not modify the original code, to achieve a hot plug effect. So a nutshell is: In order to make the program good extensibility, easy to maintain and upgrade. To achieve this, we need to use interfaces and abstract classes, which we will refer to later in the specific design.
3.2. The principle of substitution on the Richter scale (Liskov Substitution Principle)One of the fundamental principles of object-oriented design of the Richter substitution principle (Liskov Substitution Principle LSP). The Richter substitution principle says that where any base class can appear, subclasses must be able to appear. LSP is the cornerstone of inheritance reuse, only if the derived class can replace the base class, the function of the Software unit is not affected, the base class can be really reused, and the derived class can also add new behavior on the basis of the base class. The principle of substitution on the Richter scale is a supplement to the principle of "open-closed". The key step in implementing the "open-close" principle is abstraction. The inheritance of the base class and subclass is the concrete implementation of abstraction, so the principle of the substitution of the Richter scale is the specification of the concrete steps to realize the abstraction. --from Baidu Encyclopedia
3.3. Dependence reversal principle (dependence inversion Principle)This is the basis of the open and close principle, the specific content: TRUE interface programming, relying on abstraction and not dependent on the specific.
3.4. Interface Isolation principle (Interface segregation Principle)This principle means that using multiple isolated interfaces is better than using a single interface. or a reduction of the coupling between the class meaning, from here we see, in fact, the design pattern is a software design ideas, from the large software architecture, in order to upgrade and maintenance convenience. So there are multiple occurrences: reducing dependency and reducing coupling.
3.5, Dimitri Law (least known principle) (Demeter Principle)Why is it called the least known principle, that is to say: an entity should be as small as possible interaction with other entities, so that the system function module is relatively independent.
3.6. Synthetic multiplexing principles (Composite reuse Principle)The principle is to use composition/aggregation as much as possible, rather than using inheritance.

4. Summary

In the Java object-oriented programming language, different design patterns are applied in various corners, which embody these design principles.

Although the design pattern is good, but also do not mess with, sometimes, disorderly use design pattern, instead will originally very simple problem, make very complex. This requires programming experience.

Introduction to Java Design patterns