JAVA设计模式之------简单工厂模式-CSDN博客

简单工厂模式
============================================
1.简介
简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethod Pattern）,
是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
2.UML图
简单工厂模式中包含的角色及其相应的职责如下：
工厂角色（Creator）：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。
抽象（Product）产品角色：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。
具体产品（Concrete Product）角色：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

3.深入分析
简单工厂模式解决的问题是如何去实例化一个合适的对象。
简单工厂模式的核心思想就是：有一个专门的类来负责创建实例的过程。
具体来说，把产品看着是一系列的类的集合，这些类是由某个抽象类或者接口派生出来的一个对象树。而工厂类用来产生一个合适的对象来满足客户的要求。
如果简单工厂模式所涉及到的具体产品之间没有共同的逻辑，那么我们就可以使用接口来扮演抽象产品的角色；
如果具体产品之间有功能的逻辑或，我们就必须把这些共同的东西提取出来，放在一个抽象类中，然后让具体产品继承抽象类。为实现更好复用的目的，共同的东西总是应该抽象出来的。

4.实例

使用Java来编写一个计算器控制台程序，要求输入两个数和运算符号，得到结果。

出自程杰著作的《大话设计模式》，写的挺好。

public abstract class Operation {  
    protected double numA;  
      
    protected double numB;  
      
    public double getNumA() {  
        return numA;  
    }  
  
    public void setNumA(double numA) {  
        this.numA = numA;  
    }  
  
    public double getNumB() {  
        return numB;  
    }  
  
    public void setNumB(double numB) {  
        this.numB = numB;  
    }  
  
    public abstract double getResult();  
}

/* 加法 */  
public class AddOperation extends Operation {  
  
    @Override  
    public double getResult() {  
        return numA + numB;  
    }  
  
}

/* 减法 */  
public class SubOperation extends Operation {  
  
    @Override  
    public double getResult() {  
        return numA - numB;  
    }  
  
}

/* 乘法 */  
public class MulOperation extends Operation {  
  
    @Override  
    public double getResult() {  
        return numA * numB;  
    }  
  
}

/* 除法 */
public class DivOperation extends Operation {

	@Override
	public double getResult() {
		if(numB == 0)
			throw new RuntimeException("除数不能为0！");
		return numA / numB;
	}

}

上面的代码先创建了一个抽象类Operation，然后创建了加减乘除四个子类，分别实现其运算方法，
如果以后需要修改某种运算，只需要去修改相应的类即可，如果需要增加某种运算，只需要去实现Operation的getResult方法即可，
那么，我们还需要一个创建运算类的工厂。

public class OperationFactory {  
  
    public static Operation createOperation(String operate) {  
        Operation op = null;  
        if(operate == null)  
            throw new RuntimeException("运算符不能为空！");  
        else if(operate.equals("+"))  
            op = new AddOperation();  
        else if(operate.equals("-"))  
            op = new SubOperation();  
        else if(operate.equals("*"))  
            op = new MulOperation();  
        else if(operate.equals("/"))  
            op = new DivOperation();  
        else  
            throw new RuntimeException("运算符错误！");  
        return op;  
    }  
      
}

客户端代码

public class OperationTest {  
  
    public static void main(String[] args) {  
        Operation op = null;  
        Scanner scanner = new Scanner(System.in);  
        try {  
            do {  
                System.out.println("输入数字A：");  
                double numA = scanner.nextDouble();  
                System.out.println("输入运算符(+、-、*、/)：");  
                String operate = scanner.next();  
                System.out.println("输入数字B：");  
                double numB = scanner.nextDouble();  
  
                op = OperationFactory.createOperation(operate);  
                op.setNumA(numA);  
                op.setNumB(numB);  
                  
                double result = op.getResult();  
                System.out.println("运算结果为：" + result);  
                System.out.println("是否继续操作(Y/N)：");  
            } while(!scanner.next().equalsIgnoreCase("n"));  
        } catch (RuntimeException e) {  
            System.err.println("程序发生异常退出！");  
            e.printStackTrace();  
        }  
    }  
  
}

将创建对象的工作交给工厂负责，使客户端调用和运算类解耦，当我们更改运算类时，客户端代码不会受到影响，也不需要修改。同时将计算器程序中的多个分支判断拆成了各个类，当分支判断中逻辑过于复杂时，这样做是非常好的。使用面向对象语言的特性(封装、继承、多态)，以优雅的方式解决了可复用、可维护、可扩展等问题。
编程是一门技术，更是一门艺术。
UML