设计模式——简单工厂模式

定义：

　　简单工厂模式是一个由工厂来确定创建某种产品的实例。

　　先看一个简单的例子　

package com.zr.pattern.simpleFactory;

import java.util.Scanner;

/**
 * 实现计算机控制台程序，要求输入两个数和运算符得到运算结果
 * @author zr
 */
public class Calculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数");
        String firstNumber = scanner.nextLine();
        System.out.println("请输入第二个数");
        String secondNumber = scanner.nextLine();
        System.out.println("请输入运算符");
        String operator = scanner.nextLine();
        String result = "";
        try {
            switch (operator) {
            case "+":
                result = Double.valueOf(firstNumber) + Double.valueOf(secondNumber) + "";
                break;
            case "-":
                result = Double.valueOf(firstNumber) - Double.valueOf(secondNumber)+ "";
                break;
            case "*":
                result = Double.valueOf(firstNumber) * Double.valueOf(secondNumber)+ "";
                break;
            case "/":
                if(Double.valueOf(secondNumber) != 0){
                    result = Double.valueOf(firstNumber) / Double.valueOf(secondNumber)+ "";    
                }else {
                    System.out.println("除数不能为零");
                }
                break;
            }
            System.out.println("运算结果是：" + result);
        } catch (NumberFormatException e) {
            System.out.println("输入的不是数字");
        }
    }
}

 　　这个程序满足功能是没有问题，只是用计算机的思路来表述和解决问题。比如这个程序先输入一个数，在输入一个数，然后根据输入的运算符号获得结构，确实是满足了计算机的需求，但是这种程序。不容易扩展，不容易维护，不容易复用。

　　可维护：指的是如果要改，只需更改要改的的地方。比如说上面的程序我改加法 ，很可能不小心把减法的逻辑改了。

　　可扩展：指的是如果要加东西，直接加就行了，原来的代码不用动。如果上面的程序我要加个开根的功能。在switch下加分支，那么这个程序会越来越臃肿。有可能会加出毛病来。

　　可复用：代码重用。如果别的地方地方需要加减乘除的功能，上述代码完全不能用。耦合度太高了。有的人可能认为把计算的代码复制过去就行了。这不叫复用，这叫复制。如果程序里面相同的代码有很多万一，某个逻辑错了，改起来是不是很痛苦，也有可能改出问题。

面向对象的设计：继承、封装、多态

　　可以通过继承、封装、多态来把程序的耦合度降到最低。上面的计算机程序就是 输入、输出、计算全部都在一个方法里面耦合度太高

 　  封装：将业务方法抽出来。定义一个接口只有一个方法，获得运算结果

package com.zr.pattern.simpleFactory;

public interface Operator {
	public void getResult();
}

　　继承：实现这个接口，这样就容易维护和扩展，修改加法 不会影响到减法， 增加一个开根的功能，只需要实现上述的接口，而不需要修改原来的代码。

/**
 * 加法类
 * @author zr
 */
public class OperatorAdd implements Operator{
    public double firstNumber = 0;
    public double secondNumber = 0;
    
    public OperatorAdd(double firstNumber, double secondNumber) {
        this.firstNumber = firstNumber;
        this.secondNumber = secondNumber;
    }
    
    @Override
    public void getResult() {
        double result = Double.valueOf(firstNumber) + Double.valueOf(secondNumber);
        System.out.println("运算结果是：" + result);
    }
}


/**
 * 减法类
 * @author zr
 */
public class OperatorSub implements Operator{
    public double firstNumber = 0;
    public double secondNumber = 0;
    
    public OperatorSub(double firstNumber, double secondNumber) {
        this.firstNumber = firstNumber;
        this.secondNumber = secondNumber;
    }
    
    @Override
    public void getResult() {
        double result = Double.valueOf(firstNumber) - Double.valueOf(secondNumber);
        System.out.println("运算结果是：" + result);
    }
}

/**
 * 乘法类
 * @author zr
 */
public class OperatorMul implements Operator{
    public double firstNumber = 0;
    public double secondNumber = 0;
    
    public OperatorMul(double firstNumber, double secondNumber) {
        this.firstNumber = firstNumber;
        this.secondNumber = secondNumber;
    }
    
    @Override
    public void getResult() {
        double result = Double.valueOf(firstNumber) * Double.valueOf(secondNumber);
        System.out.println("运算结果是：" + result);
    }
}



/**
 * 除法类
 * @author zr
 */
public class OperatorDiv implements Operator{
    public double firstNumber = 0;
    public double secondNumber = 0;
    
    public OperatorDiv(double firstNumber, double secondNumber) {
        this.firstNumber = firstNumber;
        this.secondNumber = secondNumber;
    }
    
    @Override
    public void getResult() {
        if(Double.valueOf(secondNumber) != 0){
            double result = Double.valueOf(firstNumber) / Double.valueOf(secondNumber);
            System.out.println("运算结果是：" + result);
        }else {
            System.out.println("除数不能为零");
        }
    }
}

　　多态：工厂类来实例化对象，通过返回父类的方式实现了计算结果。

package com.zr.pattern.simpleFactory;

public class OperatorFactory {
    public static Operator createrOperator(String operator, double first, double second){
        Operator o = null;
        switch (operator) {
        case "+":
            o = new OperatorAdd(first, second);
            break;
        case "-":
            o = new OperatorSub(first, second);
            break;
        case "*":
            o = new OperatorMul(first, second);
            break;
        case "/":
            o = new OperatorDiv(first, second);
            break;
        }
        return o;
    }
}

  　　客户端类：

public class Client {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数");
        String firstNumber = scanner.nextLine();
        System.out.println("请输入第二个数");
        String secondNumber = scanner.nextLine();
        System.out.println("请输入运算符");
        String operator = scanner.nextLine();
        //加法
        Operator o = OperatorFactory.createrOperator("+", Double.valueOf(firstNumber), Double.valueOf(secondNumber));
        o.getResult();
    }
}

这样设计计算器：

1、如果要修改加法，只需要修改OperatorAdd类，不会影响其他算法。

2、如果要增加其他的复杂运算，如平方根、立方根，只需要增加相应的子类，并修改工厂类增加switch分支。

这样就实现了 可维护、可扩展、易重用（加减乘除的算法完全可以单独调用）。

 

uml类图如下