1.简单工厂模式的实质
简单工厂模式的实质是由一个工厂类根据传入的参数,动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。
2.画上流程框图
3.面向对象三大特性
这里为什么再把继承、封装、多态搬到台面上来呢?因为工厂模式离不开他呀!这几个家伙太重要了!
封装:只要你把业务和判断逻辑分别写成方法就算是封装了,这样就是实现了可维护性和复用性,当你想修改业务时候就去修改业务的方法即可。
继承:子类继承父类,提高扩展性(当你想增加一个取余数运算时,加个子类即可)
多态:[同一个行为具有不同的表现形态],当你明白了向上转型你就理解了工厂类(https://blog.csdn.net/qq_31655965/article/details/54746235)
4.贴上代码类
Operation类(父类)
package SimpleFactory;
public class Operation {
private double numberA;
private double numberB;
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 double GetResult() {
return 0;
}
}
- 运算符类(子类:加减乘除)
package SimpleFactory;
public class Add extends Operation{
@Override
public double GetResult() {
// TODO Auto-generated method stub
return getNumberA()+getNumberB();
}
}
package SimpleFactory;
public class Sub extends Operation {
@Override
public double GetResult() {
// TODO Auto-generated method stub
return getNumberA()-getNumberB();
}
}
package SimpleFactory;
public class Mul extends Operation {
@Override
public double GetResult() {
// TODO Auto-generated method stub
return getNumberA()*getNumberB();
}
}
package SimpleFactory;
public class Div extends Operation{
@Override
public double GetResult() {
// TODO Auto-generated method stub
if (getNumberB()==0) {
try {
throw new Exception("除数不能为0");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return getNumberA()/getNumberB();
}
}
- OperationFactory类(工厂类)
package SimpleFactory;
public class OperationFactory {
public static Operation creatrOperation(String operation) {
Operation oper = null;
switch (operation) {
case "+":
oper = new Add();
break;
case "-":
oper = new Sub();
break;
case "*":
oper = new Mul();
break;
case "/":
oper = new Div();
break;
default:
System.err.println("请按照要求输入运算符号!");
break;
}
return oper;
}
}
- Service客户端类(测试类)
package SimpleFactory;
import org.junit.Test;
/**
* 客户端类
* @author Halo
*
*/
public class Service {
@Test
public void testSimpleFactory() {
Operation oper =null;
oper = OperationFactory.creatrOperation("+");
oper.setNumberA(1);
oper.setNumberB(2);
System.out.println(oper.GetResult());
oper = OperationFactory.creatrOperation("-");
oper.setNumberA(1);
oper.setNumberB(2);
System.out.println(oper.GetResult());
oper = OperationFactory.creatrOperation("*");
oper.setNumberA(1);
oper.setNumberB(2);
System.out.println(oper.GetResult());
oper = OperationFactory.creatrOperation("/");
oper.setNumberA(1);
oper.setNumberB(2);
System.out.println(oper.GetResult());
// oper = OperationFactory.creatrOperation("swith里没有的运算符,如sqrt");
// oper.setNumberA(1);
// oper.setNumberB(2);
// System.out.println(oper.GetResult());
oper = OperationFactory.creatrOperation("/");
oper.setNumberA(1);
oper.setNumberB(0);
System.out.println(oper.GetResult());
}
}
5.浅析优劣
简单工厂模式,将变化的地方,用一个类表示,当需要使用,修改,删除这个变化的地方的时候,只需要创建,修改,删除指定类实例化对象即可。
优点:
工厂类是整个模式的关键.包含了必要的逻辑判断,根据外界给定的信息,决定究竟应该创建哪个具体类的对象。通过使用工厂类,外界可以从直接创建具体产品对象的尴尬局面摆脱出来,仅仅需要负责“消费”的对象就可以了。而不必管这些对象究竟如何创建及如何组织的.明确了各自的职责和权利,有利于整个软件体系结构的优化。
缺点:
由于工厂类集中了所有实例的创建逻辑,违反了高内聚责任分配原则,将全部创建逻辑集中到了一个工厂类中;它所能创建的类只能是事先考虑到的,如果需要添加新的类,则就需要改变工厂类了。
当系统中的具体产品类不断增多时候,可能会出现要求工厂类根据不同条件创建不同实例的需求,这种对条件的判断和对具体产品类型的判断交错在一起,很难避免模块功能的蔓延,对系统的维护和扩展非常不利。
总之,
1. 维护性:维护时候只需要该类的实例就行了,简单粗暴!
2. 扩展性:需要增加其他的运算符时,只需要创建对应的类,再实例化,不过需要在工厂类中添加一段条件代码,表示何种条件下调用,这点不太友好!
3. 复用性:用多少次都ok,只要实例化对象即可。