工厂方法模式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 {@Overridepublic double getResult() {// 假如某一天公司老板要求在乘法增加一个开根号，即可只需要改动这里// double result = Math.sqrt(getNumberA() + getNumberB());double result = getNumberA() + getNumberB();return result;}
}

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

/*** 乘法类，继承父类Operation* * @author maiyu* */public class NumberMul extends Operation {@Overridepublic double getResult() {double result = getNumberA() * getNumberB();return result;}
}

/*** 除法类，继承父类Operation* * @author maiyu* */
public class NumberDiv extends Operation {@Overridepublic double getResult() {double result = 0d;if (getNumberB() != 0) {result = getNumberA() / getNumberB();} else {try {throw new Exception("除数不能为0");} catch (Exception e) {// TODO Auto-generated catch blocke.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{@Overridepublic LeiFeng createLeiFeng() {return new Undergraduate();}}

志愿者工厂：

public class VolunteerFactory implements IFactory{@Overridepublic 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 = factory.createLeiFeng();student.Sweep();student.Wash();student.BuyRice();//创建一个自愿者的实例IFactory factory2 = new VolunteerFactory();Volunteer volunteer = factory2.createLeiFeng();volunteer.Sweep();volunteer.Wash();volunteer.BuyRice();}
}

输出结果：

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

工厂方法模式VS简单工厂模式相关推荐

C++工厂模式（简单工厂、工厂方法、抽象工厂）
工厂模式前言为什么要使用工厂模式优点缺点简单工厂(Simple Factory) 代码应用不足工厂方法(Factory Method) 代码应用不足抽象工厂(Abstract F ...
Java设计模式之（工厂模式）--简单工厂模式--工厂方法模式--抽象工厂模式
工厂模式: 工厂模式可以分为三类: 1)简单工厂模式(Simple Factory) 2)工厂方法模式(Factory Method) 3)抽象工厂模式(Abstract Factory) 简单工厂模 ...
工厂模式（简单工厂、工厂方法、抽象工厂）
简单工厂模式从设计模式的类型上来说,简单工厂模式是属于创建型模式,又叫做静态工厂方法(StaticFactory Method)模式,但不属于23种GOF设计模式之一.简单工厂模式是由一个工厂对象决 ...
设计模式---3（工厂方法模式的概念，工厂方法模式的实现,工厂方法模式和简单工厂模式比较）
工厂方法模式概念工厂方法模式同样属于类的创建型模式又被称为多态工厂模式 . 工厂方法模式的意义定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类当中. 核心工厂类不再负责产品的创建,这样核 ...
getresourceasstream方法_【设计模式】第三篇：一篇搞定工厂模式【简单工厂、工厂方法模式、抽象工厂模式】...
文章系列目录(持续更新中): [设计模式]第一篇:概述.耦合.UML.七大原则,详细分析总结(基于Java) [设计模式]第二篇:单例模式的几种实现And反射对其的破坏一为什么要用工厂模式之前讲 ...
工厂模式——三个工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）...
工厂模式在<Java与模式>中分为三类: 1)简单工厂模式(Simple Factory):不利于产生系列产品: 2)工厂方法模式(Factory Method):又称为多形性工厂: 3) ...
设计模式系列——三个工厂模式（简单工厂模式，工厂方法模式，抽象工厂模式）...
转自:http://www.cnblogs.com/stonehat/archive/2012/04/16/2451891.html 设计模式系列--三个工厂模式(简单工厂模式,工厂方法模式,抽象工厂 ...
C++设计模式 | Factory工厂模式（简单工厂、工厂方法、抽象工厂）
目录简单工厂工厂方法抽象工厂学习工厂模式需要有C++虚函数纯虚函数等相关继承与多态知识简单工厂在简单工厂模式中,可以根据参数的不同返回不同的实例..简单工厂模式专门定义一个类来负责创建其 ...
Java工厂模式（简单工厂、工厂方法、抽象工厂）详解
工厂模式是一种非常常用的创建型设计模式,其提供了创建对象的最佳方式.在创建对象时,不会对客户端暴露对象的创建逻辑,而是通过使用共同的接口来创建对象. 1.工厂模式的理解 1.1.工厂模式的分类工厂模 ...

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

工厂方法模式VS简单工厂模式相关推荐

最新文章

热门文章