When is the appearance pattern in the design pattern generally used?

The appearance pattern is to put multiple classes with complex relationships into one appearance class for unified processing, so that the external call only needs to deal with the appearance, without having to clear the call relationship between the internal classes, simplifying the complexity of client calls. Just like the example of sweet and sour pork ribs listed in the book "Software Secrets - Design Patterns": the chef is equivalent to the appearance, what we want to eat (such as sweet and sour pork ribs) just ask the chef (call the appearance) to order, and the chef (appearance) will do it for us, and in this process, we don't need to know the production process of sweet and sour pork ribs, so as to reduce the coupling between the client call and the various processing classes.

It is recommended that you take a look at the book "Software Secrets - Design Patterns", the examples are easy to understand, and you have gained a lot from reading! Hope the above is helpful to you!

The appearance mode belongs to the after-the-fact mode, generally when taking over a complex old system, because there is a very complex coupling association between multiple internal subsystems, in order to shield the impact of this "bad smell" on the new system, then a façade is established, and the new system only needs to face this façade (a series of interfaces).

One group develops the new system, the other maintains the old system, the new system is interface-oriented only, and how the old system changes will not affect the new system.

Similar environments can be considered for façade mode.

Function: 1. Realize the loose coupling relationship between the subsystem and the client.

2. The client shields the subsystem components, which reduces the number of objects that the client needs to process and makes the subsystem easier to use.

You can consider using Appearance Mode in the following situations:

1. In the initial stage of design, different layers should be consciously separated, and the appearance pattern should be established between layers.

2. In the development stage, the subsystem becomes more and more complex, and the appearance mode is added to provide a simple call interface.

3. When maintaining a large legacy system, it may be that the system is already very difficult to maintain and scale, but it contains very important functions, and develop a façade class for it so that the new system can interact with it.

Appearance mode allows the application to see only the appearance object, but not the specific detail object, which undoubtedly reduces the complexity of the application and improves the maintainability of the program.

The appearance pattern provides a consistent interface for a set of interfaces in a subsystem, and the appearance pattern defines a high-level interface that makes the subsystem easier to use.

The design pattern is a summary of the excellent design experience of BAI that has been used repeatedly, known by most people, and cataloged by the DAO. Inside.

How to deal with a specific problem in a specific environment.

1) Reuse design and reuse design is more meaningful than reuse and automatically brings reuse 2) Improve scalability Extensive use of interface-oriented programming, reserved expansion slots, new functions or features are easy to add to the system.

3) Increased flexibility Increasing flexibility through combination allows modifications to occur smoothly without affecting one modifier to other modules.

4) Improve development efficiency Proper use of design patterns can save a lot of time.

What kind of study do you study?

There are also many common design patterns in software design, among which engineering mode, observer mode, and ** mode are used more. In general, there are 23 patterns involved in design patterns, which are generally divided into three categories: creative patterns, structural patterns, and behavioral patterns.

Among them, the creation mode includes five design patterns: factory mode, abstract factory mode, singleton mode, builder mode, and prototype mode. The structure mode includes 8 modes involved in the slag-based adapter mode, the bridging mode, the filter mode, the combination mode, the decorator mode, and the appearance mode, such as Sojin, Xiangyuan mode, and ** mode.

There are 12 design patterns, including chain of responsibility pattern, command pattern, interpreter pattern, iterator pattern, mediator pattern, memo pattern, observer pattern, state pattern, empty object pattern, policy pattern, template method pattern, and visitor pattern.