简单工厂模式:由一个工厂对象决定创建出哪一种产品类的实例。
1.简单工厂模式是属于创建型模式，又叫做静态工厂方法模式，但不属于23种GOF设计模式之一。
2.优点：工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该
创建哪个具体类的对象.通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,
仅仅需要负责“消费”对象就可以了。而不必管这些对象究竟如何创建及如何组织的．明确了各自的
职责和权利，有利于整个软件体系结构的优化。
3.缺点：由于工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，将全部创建逻辑集中到
了一个工厂类中；它所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了。
可通过工厂方法模式克服该缺点。
/**
* 算法操作基类
*/
public class Operation {
// 数值A
private double numberA;
// 数值B
private double numberB;
public double getResult(){
double result = 0;
return result;
}
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 class OperationAdd extends Operation {
@Override
public double getResult() {
double result = 0;
result = getNumberA() + getNumberB();
return result;
}
}
/**
* 实现减法的具体运算，继承运算类
*/
public class OperationSub extends Operation {
@Override
public double getResult() {
double result = 0;
result = getNumberA() - getNumberB();
return result;
}
}
/**
* 实现乘法的具体运算，继承运算类
*/
public class OperationMul extends Operation {
@Override
public double getResult() {
double result = 0;
result = getNumberA() * getNumberB();
return result;
}
}
/**
* 实现除法的具体运算，继承运算类
*/
public class OperationDiv extends Operation {
@Override
public double getResult(){
double result = 0;
if(getNumberB()==0){
throw new RuntimeException("除数不能为0");
}
result = getNumberA() / getNumberB();
return result;
}
}
/**
* 运算符操作符枚举类
*/
public enum OperateEnum {
Add,Div,Mul,Sub;
}
/**
* 简单运算工厂类
*/
public class OperationFactory {
// 根据传入的运算符，创建具体的运算类
public static Operation createOperate(OperateEnum operate){
Operation oper = null;
switch(operate){
case Add:
oper = new OperationAdd();
break;
case Mul:
oper = new OperationMul();
case Sub:
oper = new OperationSub();
case Div:
oper = new OperationDiv();
}
return oper;
}
}
public class Main {
public static void main(String[] args) {
Operation oper = OperationFactory.createOperate(OperateEnum.Add);
oper.setNumberA(10);
oper.setNumberB(15);
System.out.println(oper.getResult());
oper = OperationFactory.createOperate(OperateEnum.Mul);
oper.setNumberA(10);
oper.setNumberB(15);
System.out.println(oper.getResult());
}
}
工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。
工厂方法使一个类的实例化延迟到其子类。
与简单工厂模式的对比：
1.简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态
实例化相关的类，对于客户端来说，去除了与具体的产品的依赖。
缺点是对扩展开放，对修改也开放，违背了开放-封闭原则。
2.工厂方法模式的优点是克服了简单工厂违背了开放-封闭原则的缺点，又保持了封装对象创建
过程的优点，是简单工厂模式的进一步抽象和推广。
缺点是每添加一个产品，就得添加一个产品工厂的类。
工厂方法模式实例：
/**
* 算法操作基类
*
*/
public class Operation {
// 数值A
private double numberA;
// 数值B
private double numberB;
public double getResult(){
double result = 0;
return result;
}
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 class OperationAdd extends Operation {
@Override
public double getResult() {
double result = 0;
result = getNumberA() + getNumberB();
return result;
}
}
/**
* 实现减法的具体运算，继承运算类
*/
public class OperationSub extends Operation {
@Override
public double getResult() {
double result = 0;
result = getNumberA() - getNumberB();
return result;
}
}
/**
* 实现乘法的具体运算，继承运算类
*/
public class OperationMul extends Operation {
@Override
public double getResult() {
double result = 0;
result = getNumberA() * getNumberB();
return result;
}
}
/**
* 实现除法的具体运算，继承运算类
*/
public class OperationDiv extends Operation {
@Override
public double getResult(){
double result = 0;
if(getNumberB()==0){
throw new RuntimeException("除数不能为0");
}
result = getNumberA() / getNumberB();
return result;
}
}
/**
* 运算类工厂接口
*
*/
public interface IFactory {
public Operation createOperation();
}
/**
* 加法类工厂
*
*/
public class FactoryAdd implements IFactory {
public Operation createOperation() {
// 返回加法运算类实例
return new OperationAdd();
}
}
/**
* 减法类工厂
*
*/
public class FactorySub implements IFactory {
public Operation createOperation() {
// 返回减法运算类实例
return new OperationSub();
}
}
/**
* 乘法类工厂
*
*/
public class FactoryMul implements IFactory {
public Operation createOperation() {
// 返回乘法运算类实例
return new OperationMul();
}
}
/**
* 除法类工厂
*
*/
public class FactoryDiv implements IFactory {
public Operation createOperation() {
// 返回除法运算类实例
return new OperationDiv();
}
}
/**
* 工厂方法实例（计算器工厂）
*
*/
public class Main {
public static void main(String[] args) {
// 加法运算，取得加法工厂类
IFactory factory = new FactoryAdd();
Operation operation = factory.createOperation();
operation.setNumberA(10);
operation.setNumberB(30);
System.out.println(operation.getResult());
// 减法运算，取得减法工厂类
factory = new FactorySub();
operation = factory.createOperation();
operation.setNumberA(10);
operation.setNumberB(30);
System.out.println(operation.getResult());
}
}