工厂方法模式VS简单工厂模式

转发请注明出处：http://blog.csdn.net/qq_28055429/article/details/51628921

One----简单工厂模式：

一，基本知识：

(1)定义：简单工厂模式是属于创建型模式，又叫做静态工厂方法(Static Factory Method)模式，但不属于23种GOF设计模式之一。

(2)理解：简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

二，实现方法和角色：

（1）实现方式：简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类(这些产品类继承自一个父类或接口)的实例。

（2）角色和责任：如图：



工厂(Creator)角色：简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。

工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
抽象产品(Product)角色：简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

具体产品(Concrete Product)角色：是简单工厂模式的创建目标，所有创建的对象都是充当这个角色的某个具体类的实例。

 三，优缺点：

（1）优点：在于工厂类中包含了必要的逻辑，根据客户需要的条件动态实例化相关的类，

对客户端来说，去掉了与具体产品的依赖。

（2）缺点：工厂类集中了所有实例的创建逻辑，违反了高内聚责任分配原则，当增加新的东东时，会违反开放-封闭原则

四，例子：

四则运算：简单工厂模式：



运算类：Operation:

public class Operation {

double numberA = 0;
double numberB = 0;
//两个get方法和set方法
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;
}
//getResult方法
public double getResult() {
double result = 0d;
return result;
}
}

简单工厂模式类：OperationFactory

/**
* 多肽实现
*
* @author maiyu
*
*/
public class OperationFactory {

public static Operation createOperate(String operate) {
Operation oper = null;
switch (operate) {
case "+":
// 向上转型
oper = new NumberAdd();
break;
case "-":
oper = new NumberSub();
break;
case "*":
oper = new NumberMul();
break;
case "/":
oper = new NumberDiv();
break;
default:
break;
}
return oper;
}
}

四个运算类：

/**
* 加法类，继承父类Operation
*
* @author maiyu
*
*/
public class NumberAdd extends Operation {
@Override
public double getResult() {
// 假如某一天公司老板要求在乘法增加一个开根号，即可只需要改动这里
// double result = Math.sqrt(getNumberA() + getNumberB());
double result = getNumberA() + getNumberB();
return result;
}
}

/**
* 减法类，继承父类Operation
*
* @author maiyu
*
*/
public class NumberSub extends Operation {
@Override
public double getResult() {
double result = getNumberA() - getNumberB();
return result;
}
}

/**
* 乘法类，继承父类Operation
*
* @author maiyu
*
*/

public class NumberMul extends Operation {
@Override
public double getResult() {
double result = getNumberA() * getNumberB();
return result;
}
}

/**
* 除法类，继承父类Operation
*
* @author maiyu
*
*/
public class NumberDiv extends Operation {
@Override
public double getResult() {
double result = 0d;
if (getNumberB() != 0) {
result = getNumberA() / getNumberB();
} else {
try {
throw new Exception("除数不能为0");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// System.out.println("除数不能为0！");
// System.out.println("以下结果是错误的!");
}
return result;
}

}

客户端：Program

import java.util.Scanner;
/**
* 客户端
* @author maiyu
*
*/
public class Program {
public static void main(String[] args) {
try {
// 输入端
Scanner scanner = new Scanner(System.in);
System.out.println("请输入数字A : ");
String numberA = scanner.next();
System.out.println("请输入操作符（+,-,*,/）：");
String numberOperation = scanner.next();
System.out.println("请输入数字B : ");
String numberB = scanner.next();

// 在这里调用格式工厂的方法
Operation oper;
oper = OperationFactory.createOperate(numberOperation);
oper.numberA = Double.parseDouble(numberA);
oper.numberB = Double.parseDouble(numberB);
double numberResult = oper.getResult();
// 打印结果
System.out.println("输出结果为：" + numberResult);

} catch (Exception e) {
System.out.println("您的输入有误：");
e.printStackTrace();
}
}

}

输出：

请输入数字A :
8
请输入操作符（+,-,*,/）：
/
请输入数字B :
3
输出结果为：2.6666666666666665
请输入数字A :
8
请输入操作符（+,-,*,/）：
/
请输入数字B :
0
java.lang.Exception: 除数不能为0
输出结果为：0.0
at operation.NumberDiv.getResult(NumberDiv.java:16)
at operation.Program.main(Program.java:24)

但这时，如果客户需求，需要增加求M的N次方的运算，在简单工厂里，就是先增加”求M得N次方“的类，然后去更改工厂方法，

增加Case语句来判断，但这时岂不是修改了原来的类，违背了开放--封闭原则，，，

那么这时就要考虑工厂方法模式了，，

TWO-----工厂方法模式

一，基本知识：

（1）定义：定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使一个类的实例化延迟到其子类。

如下图：



（2） 英文：Factory Method

二，四个要素：

工厂接口：工厂接口是工厂方法模式的核心，与调用者直接交互用来提供产品。在实际编程中，有时候也会使用一个抽象类来作为与调用者交互的接口，其本质上是一样的。

工厂实现：在编程中，工厂实现决定如何实例化产品，是实现扩展的途径，需要有多少种产品，就需要有多少个具体的工厂实现。

产品接口：产品接口的主要目的是定义产品的规范，所有的产品实现都必须遵循产品接口定义的规范。产品接口是调用者最为关心的，产品接口定义的优劣直接决定了调用者代码的稳定性。同样，产品接口也可以用抽象类来代替，但要注意最好不要违反里氏替换原则。

产品实现：实现产品接口的具体类，决定了产品在客户端中的具体行为。

三，优点：创建对象的接口，让子类去决定具体实例化的对象，把简单的内部逻辑判断移到了客户端代码。工厂方法克服了简单工厂违背开放-封闭原则的缺点，又保持了封装对象创建过程的优点。

四，理解：如下图，上面那个例子可这样改：



利用依赖倒置原则，把工厂类抽象出一个接口，里面只有一个创建抽象产品的方法，然后所有的要生成具体类的工厂去实现这个接口，这样：

一个简单工程模式的工厂类就变成了一个工厂抽象接口和多个具体生成对象的工厂，当我们需要增加例如M的N次方时，就不需要去修改原有的工厂类，只需要增加此功能的运算类和相应的工程类即可。如上图所示。

下面以一个学雷锋的例子：

雷锋类：

class LeiFeng {
public void Sweep(){
System.out.println("扫地");
}
public void Wash(){
System.out.println("洗衣服");
}
public void BuyRice(){
System.out.println("买米");
}
}

工厂接口：

interface IFactory {
LeiFeng createLeiFeng();
}

大学生工厂：

public class UndergraduateFactory implements IFactory{

@Override
public LeiFeng createLeiFeng() {

return new Undergraduate();
}

}

志愿者工厂：

public class VolunteerFactory implements IFactory{

@Override
public LeiFeng createLeiFeng() {

return new Volunteer();
}

}

大学生类：

public class Undergraduate extends LeiFeng {
public void Sweep(){
System.out.println("大学生扫地");
}
public void Wash(){
System.out.println("大学生洗衣服");
}
public void BuyRice(){
System.out.println("大学生买米");
}
}

志愿者类：

public class Volunteer extends LeiFeng {
public void Sweep(){
System.out.println("志愿者扫地");
}
public void Wash(){
System.out.println("志愿者洗衣服");
}
public void BuyRice(){
System.out.println("志愿者买米");
}
}

测试类：

public class Test {
public static void main(String[] args) {
//创建一个大学生的实例
IFactory factory = new UndergraduateFactory();
Undergraduate student = new Undergraduate();
student.Sweep();
student.Wash();
student.BuyRice();

//创建一个自愿者的实例
IFactory factory2 = new VolunteerFactory();
Volunteer volunteer = new Volunteer();
volunteer.Sweep();
volunteer.Wash();
volunteer.BuyRice();
}
}

输出结果：

大学生扫地
大学生洗衣服
大学生买米
志愿者扫地
志愿者洗衣服
志愿者买米