Simple factory mode
Class diagram
Create corresponding objects with a condition through a factory class
//Business functions public interface ICalculation { double getResult(double numA, double numB); } public class CalcAdd implements ICalculation { @Override public double getResult(double numA, double numB) { System.out.println("Add"); return numA + numB; } } public class CalcSubtract implements ICalculation { @Override public double getResult(double numA, double numB) { System.out.println("Subtraction"); return numA - numB; } } /* * Simple factory mode focuses on: object creation* Create a factory class to create instances of some classes that implement the same interface or have inheritance relationships*/ public class Test4Simple { public static void main(String[] args) { // String operation = "/"; String operation = "+"; // String operation = "-"; // String operation = "*"; double numA = 182, numB = 33; ICalculation createCalc = CalcSimpleFactory.createCalc(operation); double result = createCalc.getResult(numA, numB); System.out.println(result); } } The defects of a simple factory: When a simple factory creates a product, it is necessary to pass the corresponding parameters. If the pass is incorrect, the object cannot be retrieved.
Improvement: Create different product categories in multiple ways
public class CalcMultipleFactory { public static ICalculation produceAdd() { return new CalcAdd(); } public static ICalculation produceSubtract() { return new CalcSubtract(); } public static ICalculation produceMultiply() { return new CalcMultiply(); } public static ICalculation produceDivide() { return new CalcDivide(); } } public class Test4Multiple { public static void main(String[] args) { double numA = 182, numB = 33; ICalculation createCalc = CalcMultipleFactory.produceAdd(); double result = createCalc.getResult(numA, numB); System.out.println(result); createCalc = CalcMultipleFactory.produceSubtract(); result = createCalc.getResult(numA, numB); System.out.println(result); createCalc = CalcMultipleFactory.produceSubtract(); result = createCalc.getResult(numA, numB); System.out.println(result); createCalc = CalcMultipleFactory.produceMultiply(); result = createCalc.getResult(numA, numB); System.out.println(result); createCalc = CalcMultipleFactory.produceDivide(); result = createCalc.getResult(numA, numB); System.out.println(result); } } Abstract factory pattern
There are several concepts in it: abstract factory, physical factory, abstract product, physical product abstract factory: define the abstract method of creating products. Entity factory: specific product abstract product creation: an interface or base class entity product: implement specific functions, or derived class diagrams
//Abstract Product1 public interface IProduct1 { public void show(); } //Abstract Product2 public interface IProduct2 { public void show(); } //Entity Product1 public class Product1 implements IProduct1 { public void show() { System.out.println("Created Type 1 Product"); } } //Entity Product2 public class Product2 implements IProduct2 { public void show() { System.out.println("Created Type 2 Product"); } } /* * 1A 1B belongs to Product1 In the same product hierarchy structure* 2A 2B belongs to Product2 */ public class GradeProduct1A extends Product1 { @Override public void show() { super.show(); System.out.println("This is under Product 1: Product A"); } } public class GradeProduct1B extends Product1 { @Override public void show() { super.show(); System.out.println("This is under Product 1: Product B"); } } public class GradeProduct1B extends Product1 { @Override public void show() { super.show(); System.out.println("This is under Product 1: Product B"); } } public class GradeProduct2A extends Product2 { @Override public void show() { super.show(); System.out.println("This is under Product 2: Product A"); } } public class GradeProduct2B extends Product2 { @Override public void show() { super.show(); System.out.println("This is under Product 2: Product B"); } } //Abstract factory creates different abstract products public interface IFactory { public IProduct1 createProduct1A();//Class 1 product model A public IProduct1 createProduct1B();//Class 1 product model B public IProduct2 createProduct2A();//Class 2 product model A public IProduct2 createProduct2B();//Class 2 product model B } //Class 1 product factory creates physical products, the return type is abstract product public class Factory implements IFactory { public IProduct1 createProduct1A() { return new GradeProduct1A(); } public IProduct1 createProduct1B() { return new GradeProduct1B(); } public IProduct2 createProduct2A() { return new GradeProduct2A(); } public IProduct2 createProduct2B() { return new GradeProduct2B(); } } /* * Abstract factory pattern: used to create a set of related or interdependent objects* * Process: abstract factory, physical factory produces products* Abstract product, physical product realizes product functions* Disadvantages: When you need to add a product (consisting of abstract and entity), the factory needs to change*/ public class Test4Abstract { public static void main(String[] args) { IFactory factory = new Factory(); IProduct1 product1a = factory.createProduct1A(); product1a.show(); IProduct1 product1b = factory.createProduct1B(); product1b.show(); IProduct2 product2a = factory.createProduct2A(); product2a.show(); IProduct2 product2b = factory.createProduct2B(); product2b.show(); } }