Simple Factory mode

Pattern definition

Simple Factory pattern: Also known as the Static Factory method (Factory) mode, which belongs to the class-creation mode. In the simple factory model, you can return instances of different classes depending on the parameters , and the simple factory pattern defines a class that is responsible for creating instances of other classes, and the instances that are created typically have a common parent class

Pattern structure

1.Factory: Factory Role

The factory role is responsible for implementing the internal logic that creates all instances

2.Product: Abstract Product role

Abstract product roles are the parent of all objects created, and are responsible for describing common interfaces common to all instances

3.ConcreteProduct: Specific Product roles

The specific product role is to create the target, and all created objects act as instances of a specific class of this role

Instance

Background: Illustrate this pattern with a simple calculator < subtraction >

1. Create a factory where the class is generated by the operators that are passed in to generate the corresponding operations class

public class operationfactory {    public static operation  createoperation  (string operate)  {        operation  operation = null;        switch (operate)  {         case  "+":             operation = new operationadd ();             break;        case  "-":             operation = new operationsubtract () ;            break;         case  "*":             Operation = new&nBsp;operationmultiply ();            break;         case  "/":             operation = new operationdivide ();             break;        }         return operation;    }}

2. Define an abstract computing interface

Public interface Operation {//Gets the result of a two-digit calculation public int getresult (int numberone,int numbertwo);}

3. Each operation class to implement the Operation interface respectively

/** *  additive operations  *  @author  shengfenglai */public class OperationAdd  implements operation {     @Override     public int  GetResult (Int numberone, int numbertwo)  {         return numberone + numbertwo;    }}/** *  Subtraction Operations  *  @author  shengfenglai */public class OperationSubtract implements Operation {      @Override     public int getresult (int numberone, int  numbertwo)  {        return numberOne -  numbertwo;    }}/** *  multiplication Operation  *  @author  shengfenglai */public  class OperationMultiply implements Operation {     @Override     puBlic int getresult (Int numberone, int numbertwo)  {         return numberOne * numberTwo;    }}/** *  Division Operations  *  @author  shengfenglai */public class OperationDivide implements  operation {     @Override     public int getresult (int  numberone, int numbertwo)  {        int  Result = 0;        if (numbertwo != 0)  {             result = numberOne /  numbertwo;        }else {             throw new notbezeroexception ("Divisor cannot be 0");         }         return result;    }} 

4. Customize an exception to be thrown when the divisor is 0

public class Notbezeroexception extends RuntimeException {/** * */private static final long serialversion    UID = 9056463784173674087L;    Public notbezeroexception (String msg) {super (MSG); }}

5. Test class

Public class operationtest {    public static void main ( String[] args)  {        //test for add          Operation addOperation =  Operationfactory.createoperation ("+");        int addresult  = addoperation.getresult,         system.out.println ("1  + 2 =  " + addresult);         //test for  subtract        Operation subtractOperation =  Operationfactory.createoperation ("-");         int subtractresult  = subtractoperation.getresult (9,5);         System.out.println ("9 - 5 = "  + sUbtractresult);        //test for  multiply         Operation multiplyOperation =  Operationfactory.createoperation ("*");         int multiplyresult  = multiplyoperation.getresult (4,6);         System.out.println ("4 * 6 = "  + multiplyresult);         // test for divide        operation  divideoperation = operationfactory.createoperation ("/");         int divideresult = divideoperation.getresult (8,4);         //int divideresult = divideoperation.getresult (8,0);         system.out.println ("8 / 4 =  " + divideresult);     }} 

Pattern Benefits

The core of the pattern is the factory class, which contains the necessary judgment logic to decide when to create an instance of which product class, and the client can dispense with the responsibility to create the product object directly, but only to "consume" the product. The simple factory model realizes the division of responsibility.

Pattern disadvantage

1. Factory class Use static method as factory class, so there is no way to inherit the subclass, so there is no way to form the hierarchy of inheritance

2. Put multiple creation logic in a class, when the product class has different interface types, the factory class needs to determine when to create a product, making the system in the future to expand the function more difficult. Is that if else will be more and more, not conducive to maintenance

3. Only applicable to factory class is responsible for creating objects less

Simple Factory mode