During interviews, I often ask what are 8 of the 23 design patterns in J2EE

Generally used:

factory

singleton

These two are more.

Proxy (** mode).

adapter mode

command

observer

Facade (façade mode).

These will also be encountered.

Template MethodDecorator

Iterator (iterative subpattern).

These are rarely encountered.

As for the rest, it is unlikely that you will encounter it, and you will only use it if you meet certain conditions.

What to prepare for the written interview:

The written test of the design pattern is mainly the first 3 demos, which are simple implementations, such as the lazy and hungry mode of a singleton.

During the interview, the design pattern mainly asks about the benefits of the design, as well as the application scenarios.

How to break ???

Personally, I think that by understanding the basic implementation of these design patterns, you should be able to understand how and why these patterns are used.

Recommend GOF's book.

In general, design patterns fall into three broad categories:

There are five types of creation mode: factory method mode, special genus elephant factory mode, singleton mode, builder mode, and prototype mode.

There are seven structural modes: adapter mode, decorator mode, ** mode, appearance mode, bridge mode, combination mode, and enjoy yuan mode.

There are 11 behavioral patterns: policy mode, template method mode, observer mode, iterative sub-pattern, chain of responsibility mode, command mode, memo mode, state mode, visitor mode, mediator mode, and interpreter mode.

In fact, there are two types: concurrent mode and thread pool mode.

The most commonly used are: Factory Mode, Singleton Mode, Builder Mode, ** Mode.

In fact, it is better to know them all.

Abstract Factory Pattern, Chain of Responsibility Pattern

Proxy pattern

Command pattern and observer pattern I will have these few, it is easy to understand, it is really difficult to understand the subtleties of it, don't be greedy, it is very useful to understand one.

A total of 23 design modes!

Quote from the book "Software Secrets - Design Patterns".

According to the purpose, design patterns can be divided into creative patterns, structural patterns, and behavioral patterns.

The creative mode is used to handle the process of creating objects; Structural patterns are used to deal with combinations of classes or objects; Behavioral patterns are used to describe how classes or objects interact and how responsibilities are assigned.

The creative mode is used to deal with the process of creating objects, and mainly includes the following five design patterns:

Factory Method Pattern Abstract Factory Pattern Builder Pattern Prototype Pattern Singleton Pattern Structural patterns are used to deal with the combination of classes or objects, and mainly include the following 7 design patterns:

Adapter Pattern Bridge Pattern Composite Pattern Decorator Pattern Facade Pattern Flyweight Pattern **Proxy pattern) Behavioral patterns are used to describe how classes or objects interact and how responsibilities are assigned, and include the following 11 design patterns:

Chain of responsibility pattern

Command pattern Interpreter pattern Iterator pattern Meditor pattern Memento pattern Observer pattern State pattern Strategy pattern pattern) template method pattern visitor pattern

I'll tell you what I encountered when I was looking for a job, and I usually ask you about the singleton pattern, the observer pattern, the factory pattern, and most importantly, the MVC pattern.

There are many design patterns that we don't need because many of them are low-level implementations, such as the Iterator pattern, which is used to design an interface for traversal in the JDK. I think: in fact, what you need to master is singletons, factories, chains of responsibility, and dynamics, because these design patterns are very classic, and the object-oriented multi-too, abstraction, and inheritance are used to the fullest...

Just take a look ... Don't pattern for the sake of pattern.

If writing a program is compared to fighting, then the design pattern is a routine, such as Changquan, Yongchun or something.

It's all fights, some are heroes, and some are hooligans.

But sometimes the hero is not necessarily too big for the hooligan, because the hooligan does not play according to the routine.

The hooligan is a cow, it's amazing, the hooligan's fighting method has slowly become a new routine, and the hooligan has programmed the hero.

That's the way the design pattern is, at first GOF was four hooligans who were about the same as us, but there were many fights, they paid attention to summarizing and analyzing, and sorted out a set of routines from the group fight, which is the GOF23 mode, so they became heroes.

If you want to become a hero, it's right to learn the routines first, but you should also pay attention to the practical application and don't die the routines. Combine routines to slowly form your own style, and you will not be a hooligan.

Not at the beginning of development, but only when there are places where a certain pattern fits.

Depending on the project, the usage pattern will change, and the development companies I know of use the design pattern more often in the second and third versions of the project!

The book is a primer, and the real project doesn't have to be a design pattern.

Frameworks are formed by design patterns.

There are more than 23 design patterns in real development.

One of the most common MVC design patterns is used almost every day.

When you look at the source code of Hibernate, Spring, Struts, etc., you will find that design patterns are everywhere.

When you go to use a temple, there is a façade model, a strategy model, a ** model and other experiences in the development of the model is the model.

Don't think that there are only 23 design patterns, and you can even summarize one pattern yourself.

Use less. The slightly more commonly used patterns are: singleton and factory.

No, he's a combination of multiple design patterns.

MVC is a design idea that is higher than a design pattern.

It should not be among the 23 design patterns of the GOF. MVC is more of an architectural pattern.

MVC is a composite design pattern.

There are too many J2EE patterns, and there is a classic book on the J2EE model, but in fact, there is not a complete summary there.

There are 23 basic object-oriented patterns, so I recommend taking a look at "Talking about Design Patterns - Starting with Object-Oriented".

The Gang of Four design pattern is powerful.