工厂方法模式

1 工厂模式介绍

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

　　工厂方法模式通用类图：

　　在工厂模式中，抽象产品类Product负责定义产品的共性，实现对事物最抽象的定义，Creator为抽象类创建类，也就是抽象工厂，具体如何创建产品类是有具体的实现工厂ConcreteCreator完成的。

　　1.2 工厂方法模式的优点

• 良好的封装性，代码结构清晰。
• 扩展性非常优秀，在增加产品类的情况系下，只有适当的修改具体的工厂类或扩展一个工厂类，就可以“拥抱变化”。
• 屏蔽产品类。产品类的实现如何变化，调用者无需关心，它只需关心产品的接口，只要接口保持不变，系统中的上层模块就不需要发生变化。
• 解耦框架。高层模块只需要知道产品的抽象类，其他实现类都不用关心。

　　1.3 工厂方法模式的使用场景

2 工厂模式实现

2.1 简单工厂模式（静态工厂模式）

　　以实现一个计算器为例：

　　整个过程涉及到三个对象，人（Program4类表示）、计算器（以OperationFactory类表示）、计算方式（计算方式中有多种，加减乘除等，但都属于计算方法，以一个父类Operation，加减乘除继承覆写方法即可）。整个示例类如下图：

public class Program4 {
    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner (System.in);

            System.out.println ("请输入数字A：");
            double numberA = Double.parseDouble (scanner.nextLine ());
            System.out.println ("选择运算符(+、-、*、/):");
            String strOperate = scanner.nextLine ();
            System.out.println ("请输入数字B：");
            double numberB = Double.parseDouble (scanner.nextLine ());
            String strResult = "";

            if ( strOperate != "/" || numberB != 0){
                Operation oper;
                oper = OperationFactory.createOperate (strOperate);
                oper.setNumberA (numberA);
                oper.setNumberB (numberB);
                
                strResult = String.valueOf (oper.getResult ());
                System.out.println ("结果为："+strResult);

            }else {
                System.out.println ("除数不能为零");
            }

            scanner.close ();
        } catch (Exception e) {
            throw new RuntimeException("您输入有误:"+e.getMessage ());
        }
    }
}

 计算器（工厂）根据用户需求，选择（生成）符合需要的计算方式创建对应的实例对象，创建过程中需要需用户参与。

public class OperationFactory {
    public static Operation createOperate(String operate) {
        Operation oper = null;
        switch (operate){
            case "+":
                oper = new OperationAdd ();
                break;
            case "-":
                oper = new OperationSub ();
                break;
            case "*":
                oper = new OperationMul ();
                break;
            case "/":
                oper = new OperationDiv ();
                break;
        }
        return oper;
    }
}

public class Operation{
    private double numberA = 0;
    private double numberB = 0;

    public double getNumberA() { return numberA; }

    public void setNumberA(double numberA) { this.numberA = numberA; }

    public double getNumberB() { return numberB; }

    public void setNumberB(double numberB) { this.numberB = numberB; }

    public double getResult(){ 
        double result = 0;
        return result;
    }
}

class OperationAdd extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () + getNumberB ();
        return result;
    }
}

class OperationSub extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () - getNumberB ();
        return result;
    }
}

class OperationMul extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () * getNumberB ();
        return result;
    }
}

class OperationDiv extends Operation{
    @Override
    public double getResult() {
        double result = 0;
        result = getNumberA () / getNumberB ();
        return result;
    }
}

 简单工厂的缺点，不符合“开放封闭原则，要增加新的功能（计算方式）时，需要去修改工厂类（增加分支）。

2.2 多方法模式

是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个工厂方法模式是提供多个工厂方法，分别创建对象。

public class OperationFactory03 {

    public Operation add(){
        return new OperationAdd();
    }

    public Operation sub(){
        return new OperationSub ();
    }

    public Operation mul(){
        return new OperationMul();
    }

    public Operation div(){
        return new OperationDiv();
    }
}

public class FactoryTest {

    public static void main(String[] args) {

        OperationFactory03 factory03 = new OperationFactory03();
        Operation add = factory03.add();
        
        add.setNumberA(20);
        add.setNumberB(10);
        double result = add.getResult();
        System.out.println(result);
    }
}

2.3 静态工厂方法模式

多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。

public class OperationFactory {

    public static Operation add(){
        return new OperationAdd();
    }

    public static Operation sub(){
        return new OperationSub ();
    }

    public static Operation mul(){
        return new OperationMul();
    }

    public static Operation div(){
        return new OperationDiv();
    }
}

//调用类
public class FactoryTest {

    public static void main(String[] args) {

        Operation add = OperationFactory02.add();
        add.setNumberA(20);
        add.setNumberB(10);
        double result = add.getResult();
        System.out.println(result);
        
    }
}

　　总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传 入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式。

3  抽象工厂模式

　　工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑， 有一定的问题，如何解决？就用到抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。因为抽象 工厂不太好理解，我们先看看图，然后就和代码，就比较容易理解。

接口类

public interface Sender {
    public void Send();
}

两个实现类

public class MsgSender implements Sender{

    @Override
    public void Send() {
        System.out.println("this is msgsender");
    }
}

public class MailSender implements Sender {

    @Override
    public void Send() {
        System.out.println("this is mailsender!");
    }
}

两个工厂类

public class SendmsgFactory implements Provider {

    @Override
    public Sender produce() {
        return new MsgSender();
    }
}

public class SendmailFactory implements Provider {

    @Override
    public Sender produce() {
        return new MailSender();
    }
}

提供一个接口

public interface Provider {
    public Sender produce();
}

测试类

public class FactoryTest {
    public static void main(String[] args) {
        Provider provider = new SendmailFactory();
        Sender sender = provider.produce();
        sender.Send();
    }
}

　　其实这个模式的好处就是，如果你现在想增加一个功能：发及时信息，则只需做一个实现类，实现Sender接口，同时做一个工厂类，实现Provider接口，就OK了，无需去改动现成的代码。这样做，拓展性较好，即依赖抽象不依赖具体原则的体现。