Java design mode, java design mode pdf

Java design mode, java design mode pdf

This article is my learning notes, welcome to reprint, but please note the Source: http://blog.csdn.net/jesson20121020

 

The factory mode is the most common mode, because the factory mode is equivalent to creating A new instance object. We often need to generate instance Objects Based on Class, such as a A = new (), the factory mode is also used to create instance objects. Therefore, you need to have multiple eyes in the future when you are new. Can you consider using the factory mode.

The simple factory model can be divided into three modes:

1) Common simple factory Model

2) simple multi-method factory Model

3) simple factory mode with Multiple Static Methods

Common simple factory mode:

Example: (simple arithmetic operation)

1. Create a common interface for the four arithmetic operations:

// Operation interface public interface Operator {public double Operate (double d, double e );}

2. Create an implementation class for addition, subtraction, multiplication, division:

// Addition class public class AddOperator implements Operator {@ Overridepublic double Operate (double a, double B) {// TODO Auto-generated method stubreturn a + B ;}}

public class SubOperator implements Operator {@Overridepublic double Operate(double a, double b) {// TODO Auto-generated method stubreturn a - b;}}

public class MulOperator implements Operator {@Overridepublic double Operate(double a, double b) {// TODO Auto-generated method stubreturn a * b ;}}

Public class DivOperator implements Operator {@ Overridepublic double Operate (double a, double B) {try {if (B = 0) throw new Exception ("the divisor cannot be 0! ");} Catch (Exception e) {// TODO Auto-generated catch blocke. printStackTrace ();} return a/B ;}}

3. Create a factory class:

public class OperatorFactory {public Operator createOperator(String operate){Operator oper = null;switch(operate){case "+" :oper = new AddOperator();break;case "-" :oper = new SubOperator();break;case "*" :oper = new MulOperator();break;case "/" :oper = new DivOperator();break;}return oper;}}

4. Finally, it is the test class:

public class FactoryTest {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stubOperatorFactory factory = new OperatorFactory();Operator oper = factory.createOperator("*");double result = oper.Operate(3.6,4.8);System.out.println(result);}}

Simple factory mode with multiple methods:

In the preceding common simple factory mode, imagine that an object cannot be correctly created if the passed parameter is null or another invalid character, the multi-method simple factory mode provides multiple factory methods to create objects respectively.

The difference is only in the factory class. The changes are as follows:

public class OperatorFactory {public Operator createAddOperator(){return new AddOperator();}public Operator createSubOperator(){return new SubOperator();}public Operator createMulOperator(){return new MulOperator();}public Operator createDivOperator(){return new DivOperator();}}

In this way, you do not need to pass the corresponding parameters during the test. You only need to call the required factory method:

public class FactoryTest {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stubOperatorFactory factory = new OperatorFactory();/*Operator oper = factory.createOperator("*");*/Operator oper = factory.createMulOperator();double result = oper.Operate(3.6,4.8);System.out.println(result);}}

Simple factory mode with Multiple Static Methods:

The so-called static method sets the factory method in the above factory class to static. You can directly call it without creating an instance.

public class OperatorFactory {public static Operator createAddOperator(){return new AddOperator();}public static Operator createSubOperator(){return new SubOperator();}public static  Operator createMulOperator(){return new MulOperator();}public static Operator createDivOperator(){return new DivOperator();}}

As shown above, if the factory method is set to static, it can be called directly during testing.

public class FactoryTest {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stub //OperatorFactory factory = new OperatorFactory();/*Operator oper = factory.createOperator("*");*/Operator oper = OperatorFactory.createMulOperator();double result = oper.Operate(3.6,4.8);System.out.println(result);}}

In general, the factory mode is suitable: when a large number of products need to be created and have common interfaces, they can be created through the factory method mode. In the above three modes, if the input string is incorrect, the object cannot be correctly created, and the third mode does not need to instantiate the factory class. Therefore, in most cases, we will choose the third static factory method mode.

Java 23 design modes

There are three types of design patterns: creation, structure, and behavior.
The creation types include:
I. Singleton, Singleton mode: ensure that a class has only one instance and provide a global access point to it.
2. Abstract Factory: provides an interface for creating a series of related or mutually dependent objects without specifying their specific classes.
3. Factory Method: Define an interface used to create objects, and let the subclass decide which class to instantiate. Factory Method delays the instantiation of a class to the subclass.
4. Builder: separates the construction of a complex object from its representation, so that different representations can be created during the same construction process.
5. Prototype: Use a Prototype instance to specify the type of the object to be created, and copy the Prototype to create a new object.
Behavior types:
6. Iterator: provides a method to access each element of an aggregate object sequentially without exposing the internal representation of the object.
7. Observer: Observer mode: defines one-to-many dependencies between objects. When the status of an object changes, all objects dependent on it will be automatically updated by notification.
8. Template Method: defines the skeleton of an algorithm in an operation, and delays some steps to the subclass, templateMethod allows the subclass to redefine a specific step without changing the structure of an algorithm.
9. Command: encapsulate a request as an object so that you can parameterize the customer with different requests, queue requests and record request logs, and supports unrecoverable operations.
10. State: allows an object to change its behavior when its internal State changes. The object seems to have changed its class.
11. Strategy: Define a series of algorithms, encapsulate them one by one, and enable them to replace each other. This mode allows algorithms to be independent of customers who use them.
12. China of Responsibility, Responsibility chain mode: Enables multiple objects to process requests to avoid coupling between the request sender and receiver.
13. Mediator: uses an intermediary object to encapsulate object interaction of some columns.
14. Visitor, Visitor mode: indicates an operation that acts on each element in an object structure. It allows you to define new operations that act on this element without changing the element classes.
15th, Interpreter, Interpreter mode: a language is defined to define a representation of its grammar and an Interpreter. This Interpreter uses this representation to explain sentences in the language.
16. Memento: capture the internal state of an object without interrupting the object, and save the state outside the object.
There are:
17. Composite: Composite combines objects into a tree structure to represent the relationship between parts of the whole. Composite makes the use of a single object and a Composite object consistent.
18. Facade, appearance mode: provides a consistent interface for a group of interfaces in the subsystem. fa? Ade provides a high-level interface, which makes the subsystem easier to use.
19. Proxy: provides a Proxy for other objects to control access to this object.
20. Adapter: the Adapter mode converts a class of interfaces into another interface that the customer wants. The Adapter mode makes those classes unable to work together due to interface incompatibility.
21. Decrator: the Decorator mode dynamically adds some additional responsibilities to an object. In terms of the added functions, the Decorator mode is more flexible than the subclass generation mode.
22. Bridge: link the abstract Part with its implementation... the remaining full text>

Java 23 design modes

There are three types of design patterns: creation, structure, and behavior.
The creation types include:
I. Singleton, Singleton mode: ensure that a class has only one instance and provide a global access point to it.
2. Abstract Factory: provides an interface for creating a series of related or mutually dependent objects without specifying their specific classes.
3. Factory Method: Define an interface used to create objects, and let the subclass decide which class to instantiate. Factory Method delays the instantiation of a class to the subclass.
4. Builder: separates the construction of a complex object from its representation, so that different representations can be created during the same construction process.
5. Prototype: Use a Prototype instance to specify the type of the object to be created, and copy the Prototype to create a new object.
Behavior types:
6. Iterator: provides a method to access each element of an aggregate object sequentially without exposing the internal representation of the object.
7. Observer: Observer mode: defines one-to-many dependencies between objects. When the status of an object changes, all objects dependent on it will be automatically updated by notification.
8. Template Method: defines the skeleton of an algorithm in an operation, and delays some steps to the subclass, templateMethod allows the subclass to redefine a specific step without changing the structure of an algorithm.
9. Command: encapsulate a request as an object so that you can parameterize the customer with different requests, queue requests and record request logs, and supports unrecoverable operations.
10. State: allows an object to change its behavior when its internal State changes. The object seems to have changed its class.
11. Strategy: Define a series of algorithms, encapsulate them one by one, and enable them to replace each other. This mode allows algorithms to be independent of customers who use them.
12. China of Responsibility, Responsibility chain mode: Enables multiple objects to process requests to avoid coupling between the request sender and receiver.
13. Mediator: uses an intermediary object to encapsulate object interaction of some columns.
14. Visitor, Visitor mode: indicates an operation that acts on each element in an object structure. It allows you to define new operations that act on this element without changing the element classes.
15th, Interpreter, Interpreter mode: a language is defined to define a representation of its grammar and an Interpreter. This Interpreter uses this representation to explain sentences in the language.
16. Memento: capture the internal state of an object without interrupting the object, and save the state outside the object.
There are:
17. Composite: Composite combines objects into a tree structure to represent the relationship between parts of the whole. Composite makes the use of a single object and a Composite object consistent.
18. Facade, appearance mode: provides a consistent interface for a group of interfaces in the subsystem. fa? Ade provides a high-level interface, which makes the subsystem easier to use.
19. Proxy: provides a Proxy for other objects to control access to this object.
20. Adapter: the Adapter mode converts a class of interfaces into another interface that the customer wants. The Adapter mode makes those classes unable to work together due to interface incompatibility.
21. Decrator: the Decorator mode dynamically adds some additional responsibilities to an object. In terms of the added functions, the Decorator mode is more flexible than the subclass generation mode.
22. Bridge: link the abstract Part with its implementation... the remaining full text>