工厂模式有三种：简单工厂模式，工厂方法模式和抽象工厂模式

工厂模式

  • 将实例化对象的代码提取出来，放到一个类中统一管理和维护，达到和主项目依赖关系的解耦，从而提高项目的扩展和维护性。
  • 创建对象实例时，不去直接new，而是把这个new类的动作放到一个工厂方法中。
  • 不让类继承具体类，而是继承抽象类或者是实现接口。
  • 不要覆盖基类中已经实现的方法。

简单工厂模式

简单工厂模式属于创建型模式，是工厂模式的一种。是工厂模式家族中最简单实用的模式。
简单工厂模式：定义一个创建对象的类，由这个类来封装实例化对象的行为。

写一个计算器的例子:

  1. //定义一个操作基类
  2. public abstract class Operation {
  3.     private double number_a;
  4.     private double number_b;
  6.     public abstract double getResult();
  7.     //  省略getter setter方法...
  8. }
  10. //加法运算类
  11. public class OperationAdd extends Operation{
  12.     @Override
  13.     public double getResult() {
  14.         return getNumber_a()+getNumber_b();
  15.     }
  16. }
  18. //减法运算类
  19. public class OperationSub extends Operation{
  20.     @Override
  21.     public double getResult() {
  22.         return getNumber_a()-getNumber_b();
  23.     }
  24. }
  26. //静态工厂类
  27. public class Operationfactory {
  28.     public static Operation createOperate(String operate){
  29.        Operation oper = null;
  30.        if(operate == "+"){
  31.            oper = new OperationAdd();
  32.        }else if(operate == "-"){
  33.            oper = new OperationSub();
  34.        }
  35.        return oper;
  36.     }
  37. }
  39. //计算测试
  40. public class SimpleFactory {
  41.     public static void main(String[] args) {
  42.         Operation oper;
  43.         oper = Operationfactory.createOperate("+");
  44.         oper.setNumber_a(5.5);
  45.         oper.setNumber_b(3.4);
  46.         double result = oper.getResult();
  47.         System.out.println(result); //8.9
  48.     }
  49. }

工厂方法模式

工厂方法模式：定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

将上面的代码进行改进，就是不要那个Operationfactory静态工厂类了。

  1. //定义一个操作基类
  2. public abstract class Operation {
  3.     private double number_a;
  4.     private double number_b;
  6.     public abstract double getResult();
  7.     //  省略getter setter方法...
  8. }
  10. //加法运算类
  11. public class OperationAdd extends Operation{
  12.     @Override
  13.     public double getResult() {
  14.         return getNumber_a()+getNumber_b();
  15.     }
  16. }
  18. //定义一个创建操作符的接口
  19. public interface FactoryFunction {
  20.     Operation createOperation();
  21. }
  23. //加法操作符工厂实现这个接口 在这个工厂里返回对象
  24. public class AddFactory implements FactoryFunction{
  25.     @Override
  26.     public Operation createOperation() {
  27.         return new OperationAdd();
  28.     }
  29. }
  31. public static void main(String[] args) {
  32.     //获取操作符的时候用加法工厂获取对象
  33.     FactoryFunction factory = new AddFactory();
  34.     Operation oper = factory.createOperation();
  35.     oper.setNumber_a(5.5);
  36.     oper.setNumber_b(3.4);
  37.     double result = oper.getResult();
  38.     System.out.println(result); //8.9
  39. }


抽象工厂模式

抽象工厂模式：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。

从设计层面看，抽象工厂模式就是对简单工厂模式的改进，或者说是进一步的抽象。将工厂抽象成两层，分为抽象工厂和具体实现的子类工厂。这样将单个的简单工厂类变成了工厂簇，更利于代码的维护和扩展。

image.png