工厂模式的抽象介绍与实现

工厂模式的抽象介绍与实现

为什么需要工厂模式,对比简单工厂模式,工厂模式优势在哪里?

简单工厂模式的优点在于实例化类是在工厂类中进行选择,根据客户端的选择在工厂中实例化类,但是这优点同样也是缺点,我们要增加功能时,我们则需要修改工厂类中的代码,这违反了开放-封闭原则(对扩展开放,对修改封闭)。工厂模式则解决了这一问题。

什么是工厂模式？

定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。

大白话解释：使用工厂模式，决定具体功能类的实例化不再在工厂类中进行，而是转移到客户端类中。这同样也是工厂模式的缺点，每增加一个产品就要增加一个相应的工厂类。

逻辑说明：首先定义一个抽象的产品类，具体的产品类继承并且扩展，定义一个抽象的工厂类，声明一个返回抽象产品类的抽象方法，具体的工厂类继承并且重写方法。在客户端我们直接调用具体工厂类的方法，具体工厂类实际上实例化的是具体的产品类，但是用抽象的产品类接受，直接调用即可。

工厂模式的抽象介绍

uml图

Product类

public abstract class Product {
    public abstract void operation();
    //抽象的产品
}

ConcreteProduct类

public class ConcreteProduct extends Product {
    //具体的产品
    @Override
    public void operation() {
        System.out.println("具体产品实现功能");
    }
}

Creator类

public abstract class Creator {
    //创建产品
    public abstract Product createConcreteProduct();
 
}

ConcreteCreator类

public class ConcreteCreator extends Creator {
    //具体工厂返回具体实例,使用抽象产品作为返回值
    @Override
    public Product createConcreteProduct() {
        System.out.println("返回具体产品");
        return new ConcreteProduct();
    }
}

工厂模式的简单实现

场景：仍然以计算功能为例

Operation类对应product类

public abstract class Operation extends OperationFactory {
    private double a;
    private double b;

    public double getA() {
        return a;
    }

    public void setA(double a) {
        this.a = a;
    }

    public double getB() {
        return b;
    }

    public void setB(double b) {
        this.b = b;
    }

    public abstract double getResult();
}

OperationAdd类对应ConcreteProduct类

public class OperationAdd extends Operation {

    @Override
    public double getResult() {

        double result = 0.0;
        result = getA()+getB();
        return  result;
    }
}

Creator类对应Creator类

public abstract class Creator {
    public abstract  Operation createOperation();
}

AddFactory类对应ConcreteCreator类

public class AddFactory extends Creator{
    @Override
    public Operation createOperation() {
        return new OperationAdd();
    }
}

Client类

public class Client {
    public static void main(String[] args) {
        Operation operation = new AddFactory().createOperation();
        operation.setA(1.0);
        operation.setB(2.0);
        double result = operation.getResult();
        System.out.println(result);
    }
}

那么我们现在就可以进行对应的扩展，比如扩展减法功能

我们定义一个具体减法工厂类继承抽象工厂类

public class DivFactory extends Creator{
    @Override
    public Operation createOperation() {
        return new OperationDiv();
    }
}

具体的减法类

public class OperationDiv extends Operation {

    @Override
    public double getResult() {

        double result = 0.0;
        result = getA()-getB();
        return  result;
    }
}

客户端调用

检验，相比较之前的客户端类只是修改了具体工厂类

public class Client {
    public static void main(String[] args) {
        Operation operation = new DivFactory().createOperation();
        operation.setA(1.0);
        operation.setB(2.0);
        double result = operation.getResult();
        System.out.println(result);
    }
}