标签：-- import 类继承 pack 静态 null 分支 责任 就是
简单工厂模式又被成为静态方法模式（因为在工厂类中定义了一个静态方法）。
创建抽象产品类(创建计算类operation类)或者接口
创建具体的产品类，继承或者实现相应的抽象产品类。
创建工厂类，通过创建静态方法根据传入不同的参数，从而创建不同的具体产品类实例。
问题：实现一个计算器的功能。
package Golf;
?
import java.util.Scanner;
?
/**
* @author bm
* 计算器的实现--第一版
*/
class Caculate{
public static void main(String[] args) {
double result = 0;
//创建Scanner对象，接受从控制台输入
Scanner input=new Scanner(System.in);
System.out.println("请输入第一个数：");
String numA = input.next();
System.out.println("请输入运算符(+、-、*、/)");
String operater = input.next();
System.out.println("请输入第二个数：");
String numB = input.next();
switch(operater){
case "+":
result = Double.parseDouble(numA) + Double.parseDouble(numB);
break;
case "-":
result = Double.parseDouble(numA) - Double.parseDouble(numB);
break;
case "*":
result = Double.parseDouble(numA) + Double.parseDouble(numB);
break;
case "/":
if(Double.parseDouble(numB) != 0){
result = Double.parseDouble(numA) + Double.parseDouble(numB);
break;
}else{
System.out.println("被除数不能为0！");
}
?
}
System.out.println("结果为："+result);
?
}
}
这样实现了计算器的功能，但是耦合度高，业务逻辑和界面耦合度高。复用性差，如果想要修改功能或者添加功能，很麻烦。一个对象的功能要单一，不要有多重作用。
运用面向对象的思想，将计算器分为两部分，一部分进行逻辑的运算，一部分进行页面的展示。
package com.golf.test;
?
/**
* @author bm
* 计算器--第二版 业务逻辑部分（计算的过程）
*/
public class Operation {
public static double GetResult(String numA,String numB,String operater){
double result = 0;
switch(operater){
case "+":
result = Double.parseDouble(numA) + Double.parseDouble(numB);
break;
case "-":
result = Double.parseDouble(numA) - Double.parseDouble(numB);
break;
case "*":
result = Double.parseDouble(numA) + Double.parseDouble(numB);
break;
case "/":
if(Double.parseDouble(numB) != 0){
result = Double.parseDouble(numA) + Double.parseDouble(numB);
break;
}else{
System.out.println("被除数不能为0！");
}
}
return result;
}
}
?
package com.golf.test;
?
import java.util.Scanner;
?
/**
* 计算器的展示界面
*/
public class CaculateShow {
public static void main(String[] args) {
//创建Scanner对象，接受从控制台输入
Scanner input=new Scanner(System.in);
System.out.println("请输入第一个数：");
String numA = input.next();
System.out.println("请输入运算符(+、-、*、/)");
String operater = input.next();
System.out.println("请输入第二个数：");
String numB = input.next();
double result = Operation.GetResult(numA, numB, operater);
System.out.println("结果为："+result);
}
}
?
使用了面向对象的思想后，将计算器的业务逻辑和展示界面进行分离。但是不方便进行添加新的功能。譬如，我想要添加开根(sqrt)的功能，就要在Operation类的switch分支上进行添加相应的功能，这样一个不慎会对原来良好的代码产生影响。
我们倘若使用简单工厂模式呢？创建相应的抽象类operation，相应的功能创建具体的类继承抽象类Operation，在通过创建一个工厂类，按照用户的需求通过工厂类创建相应的运算类进行运算。
package com.golf.test2;
/**
*抽象类
**/
public class Operation {
private String numA;
private String numB;
private double result;
?
public String getNumA() {
return numA;
}
?
public void setNumA(String numA) {
this.numA = numA;
}
?
public String getNumB() {
return numB;
}
?
public void setNumB(String numB) {
this.numB = numB;
}
?
public double getResult(String numA, String numB){
return result;
}
?
public double getResult() {
return result;
}
?
public void setResult(double result) {
this.result = result;
}
}
?
加法类
package com.golf.test2;
?
/**
* 加法运算
*/
public class OperationAdd extends Operation{
?
?
public double getResult(String numA,String numB){
?
double result = Double.parseDouble(numA) + Double.parseDouble(numB);
return result;
}
}
?
减法类
package com.golf.test2;
?
/**
* 加法运算
*/
public class OperationSub extends Operation{
?
?
public double getResult(String numA,String numB){
double result = Double.parseDouble(numA) - Double.parseDouble(numB);
return result;
}
}
如果有需要其他的运算符，创建相应的类去继承抽象类就行。
package com.golf.test2;
?
/**
* 计算器的工厂类 （工厂类的创建对象方法一般用static进行修饰，这样不必去创建对象，返回值就是抽象类）
*/
public class OperationFactory {
public static Operation createOperation(String operater){
Operation operation = null;
switch (operater){
case "+":
operation = new OperationAdd();
break;
case "-":
operation = new OperationSub();
break;
}
return operation;
}
}
?
package com.golf.test2;
?
import java.util.Scanner;
?
/**
* 计算器的页面展示
*/
public class OperationShow {
public static void main(String[] args) {
Operation operation = null;
operation= OperationFactory.createOperation("+");
Scanner input=new Scanner(System.in);
System.out.println("请输入第一个数：");
String numA = input.next();
System.out.println("请输入第二个数：");
String numB = input.next();
operation.setNumA(numA);
operation.setNumB(numB);
double result = operation.getResult(operation.getNumA(),operation.getNumB());
System.out.println("结果为："+result);
}
}
?
这样就是一个很好的简单工厂模式的代码，倘若我们需要更改加法运算，那么我们去修改OperationAdd类就行，倘若我们想要加相应的运算。那么我们创建相应的类去继承抽象类Operation，并且在工厂类OperationFactory中进行添加创建相应的类就行。
可以根据外界给定的信息(参数)，交给工厂类去创建那个具体的对象。避免了直接去创建具体对象，使用者通过工厂类便可以使用相应的对象，不需要去管对象如何创建的。有利于软件体系结构的优化。
缺点：
由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部的对象创建逻辑放在一个工厂类中，这样创建的类只能事先进行考虑到，倘若要创建新的类需要频繁的修改工厂类。然而当具体产品类不断的增多时，根据不同的条件创建不同实体类，这样会使得工厂类的逻辑越来越复杂。
标签：-- import 类继承 pack 静态 null 分支 责任 就是
原文地址：https://www.cnblogs.com/bm654/p/11865222.html
