感谢大家的支持,你们的支持就是我的动力，如果对您有所帮助，请转发并收藏，谢谢！
定义
从设计模式的类型上来说，简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式。
需求
使用Java来编写一个计算器控制台程序，要求输入两个数和运算符号，得到结果。
实现
范例一
import java.util.Scanner;
public class TestDemo{
public static void main(String[] args) {
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();
double result = 0.0;
if(operate.equals(“+”)){
result = numA + numB;
}else if(operate.equals(“-“)){
result = numA – numB;
}else if(operate.equals(“*”)){
result = numA * numB;
}else if(operate.equals(“/”)){
result = numA / numB;
}else if(numB == 0.0){
System.err.println(“除数不能为0”);
}else{
System.err.println(“运算符输入有误”);
}
System.out.println(“运算结果为：” + result);
System.out.println(“是否继续操作（Y/N）:”);
}while(!scanner.next().equalsIgnoreCase(“n”));
}catch(RuntimeException e){
System.out.println(“程序发生异常退出！”);
}
}
}
上面的程序实现了最基本的四则运算，并对基本的异常进行了处理，还可以循环运算 。假如说我别处也需要一个运算的程序，还需要再写一份，难复用。我们需要一份可以复用的代码！
范例二
import java.util.Scanner;
public class TestDemo{
public static void main(String[] args) {
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();
double result = getResult(numA,numB,operate);
System.out.println(“运算结果为：” + result);
System.out.println(“是否继续操作（Y/N）”);
}while(!scanner.next().equalsIgnoreCase(“n”));
}catch(RuntimeException e){
System.err.println(“程序发生异常退出”);
}
}
public static double getResult(double numA , double numB , String operate){
double result = 0.0;
if(operate.equals(“+”)){
result = numA + numB;
}else if(operate.equals(“-“)){
result = numA – numB;
}else if(operate.equals(“*”)){
result = numA * numB;
}else if(operate.equals(“/”)){
result = numA / numB;
}else if(numB == 0){
System.err.println(“除数不能为0”);
}else{
System.err.println(“运算符输入有误”);
}
return result;
}
}
上面的程序将计算器的代码封装到一个方法中，供客户端调用，这样如果存在多个客户端，只需要调用这个方法即可，实现了代码的可复用 。那么现在我们把这个工具类编译后，其他人就可以使用了，假如说现在需要添加一个新算法，求A的B次方，我们就需要修改这个类的源代码，在getResult中加入新的分支，然后重新编译，供客户端使用，难扩展。
范例三
import java.util.Scanner;
abstract class op eration{
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();
}
class AddOperation extends Operation{
@ Override
public double getResult() {
// TODO Auto-generated method stub
return numA + numB;
}
}
class SubOperation extends Operation{
@Override
public double getResult() {
// TODO Auto-generated method stub
return numA – numB;
}
}
class MulOperation extends Operation{
@Override
public double getResult() {
// TODO Auto-generated method stub
return numA * numB;
}
}
class DivOperation extends Operation{
@Override
public double getResult() {
// TODO Auto-generated method stub
if(numB == 0){
throw new RuntimeException(“除数不能为0”);
}
return numA / numB;
}
}
// 上面的代码先创建了一个抽象类Operation，然后创建了加减乘除四个子类，分别实现其运算方法 ，如果以后需要修改某种运算，只需要去修改相应的类即可，如果需要增加某种运算，只需要去实现Operation的getResult方法即可，那么，我们还需要一个创建运算类的工厂。
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 TestDemo{
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.out.println(“程序发生异常退出”);
e.printStackTrace();
}
}
}
将创建对象的工作交给工厂负责，使客户端调用和运算类解耦，当我们更改运算类时，客户端代码不会受到影响，也不需要修改。同时将计算器程序中的多个分支判断拆成了各个类，当分支判断中逻辑过于复杂时，这样做是非常好的。使用面向对象语言的特性(封装、继承、多态)，以优雅的方式解决了可复用、可维护、可扩展等问题。
