what are java design patterns

Design pattern (Design pattern) is a set of classified and cataloged summary of code design experience that is used repeatedly, known to most people. The purpose of using design patterns is to reuse code, make the code easier to understand by others, and ensure code reliability.

There is no doubt that design patterns are win-win for ourselves, others and the system. Design patterns make code compilation truly engineering. Design patterns are the cornerstone of software engineering. Just like the bricks and stones of a building. Reasonable use of design patterns in projects can perfectly solve many problems. Each pattern has a corresponding principle to correspond to it. Each pattern describes a problem that keeps recurring around us, and the core of the problem. solution, which is why it is widely used. To put it simply:

Pattern: In certain scenarios, a certain general solution to a certain type of problem.

Scene: The environment where the project is located

Problem: Constraints, project goals, etc.

Solution: Universal, reusable design, solve constraints to achieve goals.

# Design mode of design mode

: The mode of instantiated objects, the creation mode is used for the instantiated process of decoupled objects.

Structural pattern: Combining classes or objects together to form a larger structure.

Behavioral pattern: how classes and objects interact, and how to divide responsibilities and algorithms.

##Key points of the patterns in each category                                                                                                                                                                                                                             An instance provides a global access point. Simple factory: A factory class determines which instance of the product class to create based on the parameters passed in.

Factory method: Define an interface for creating objects and let the subclass decide which class to instantiate.

Abstract Factory: Creates a family of related or dependent objects without explicitly specifying a concrete class.

Builder pattern: Encapsulates the construction process of a complex object and can construct it step by step.

Prototype mode: Create new instances by copying existing instances.

Adapter pattern: Convert the method interface of a class into another interface that the customer wants.

Combined mode: Combine objects into a tree structure to represent the ""part-whole"" hierarchy.

Decoration mode: Dynamically add new functions to objects.

Proxy mode: Provide a proxy for other objects to control access to this object.

Hengyuan (fly volume) mode: effectively supports a large number of fine-grained objects through shared technology.

Appearance mode: Provides a unified method to the outside world to access a group of interfaces in the subsystem.

Bridge mode: Separate the abstract part from its implementation part so that they can change independently.

Template pattern: Define an algorithm structure and defer some steps to subclass implementation.

Interpreter pattern: Given a language, define a representation of its grammar, and define an interpreter.

Strategy pattern: Define a series of algorithms, encapsulate them, and make them interchangeable.

State pattern: allows an object to change its behavior when its internal state changes.

Observer pattern: one-to-many dependency relationship between objects.

Memo mode: Maintain the internal state of the object without destroying the encapsulation.

Mediator pattern: Use a mediator object to encapsulate a series of object interactions.

Command mode: Encapsulate the command request as an object so that different requests can be parameterized.

Visitor pattern: Add new functions that act on a set of object elements without changing the data structure.

Chain of responsibility model: Decouple the sender and receiver of the request so that multiple objects have the opportunity to process the request.

Iterator pattern: A method of traversing and accessing each element in an aggregate object without exposing the internal structure of the object.

The above is the detailed content of what are java design patterns. For more information, please follow other related articles on the PHP Chinese website!