标签：编程语言 ber 切换 交换 ann default art 迪米特法则 静态
简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。
是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
我们从一个实例展开
现在有一道面试题：使用java实现一个计算机控制台程序，要求输入数的运算，得到结果。
这道题目最原始的写法：
public class Computer {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入第一个数字");
float firstNum = in.nextFloat();
System.out.println("请输入第二个数字");
float secondNum = in.nextFloat();
System.out.println("请输入运算符");
String countQuato = in.next();
if("+".equals(countQuato)){
System.out.println("result:"+(firstNum+ secondNum) );
}else if("-".equals(countQuato));{
System.out.println("result:"+(firstNum- secondNum) );
}else if("*".equals(countQuato));{
System.out.println("result:"+(firstNum* secondNum) );
}else if("/".equals(countQuato));{
System.out.println("result:"+(firstNum/ secondNum) );
}
}
上面的写法实现虽然简单，但是却没有面向对象的特性，代码拓展性差，显然不是出题者想要考察的意图。
那么面向对象编程要如何在题中体现呢？
在面向对象编程语言中，一切都是对象，所以上面运算符号也应当作对象来处理。
public abstract class Operation {
public abstract float getResult(float firstNumber,float secondNumber);
}
我们首先建立一个抽象类
public class OperationFactory {
public static Operation getOperation(String quotaFlag){
Operation o = null;
switch (quotaFlag){
case "+": o =new AddOptation();
case "-": o =new SubOperationFactory();
case "*": o =new MulOperation();
case "/": o =new DivOperation();
default:break;
}
return o;
}
}
public class AddOPeration extends OPeration {
public float getResult(float firstNumber ,float secondNumber ){
return firstNumber+secondNumber;
}
}
public class SubOPeration extends OPeration {
public float getResult(float firstNumber ,float secondNumber ){
return firstNumber-secondNumber;
}
}
public class MulOPeration extends OPeration {
public float getResult(float firstNumber ,float secondNumber ){
return firstNumber*secondNumber;
}
}
public class DivOPeration extends OPeration {
public float getResult(float firstNumber ,float secondNumber ){
return firstNumber/secondNumber;
}
}
import java.util.Scanner;
public class Computer {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入第一个数字");
float firstNum = in.nextFloat();
System.out.println("请输入第二个数字");
float secondNum = in.nextFloat();
System.out.println("请输入运算符");
String countQuato = in.next();
if("+".equals(countQuato)){
System.out.println("result:"+(firstNum+ secondNum) );
}else if("-".equals(countQuato));{
System.out.println("result:"+(firstNum- secondNum) );
}else if("*".equals(countQuato));{
System.out.println("result:"+(firstNum* secondNum) );
}else if("/".equals(countQuato));{
System.out.println("result:"+(firstNum/ secondNum) );
}
}
private static float count(float firstNum,float secondNum,String countQuato){
//通过工厂类获取对象
Operation Operation =OperationFactory.getOperation(countQuota);
return operation.getResult(firstNum,secondNum);
}
}
}
简单工厂将对象的创建过程进行了封装，用户不需要知道具体的创建过程，只需要调用工厂类获取对象即可。
这种简单工厂的写法是通过switch-case来判断对象创建过程的。在实际使用过程中，违背了 开放-关闭原则，当然有些情况下可以通过反射调用来弥补这种不足。
简单工厂的优点/缺点：
2 工厂方法 定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使得一个类的实例化延迟到了子类
工厂方法在简单工厂的基础上再包了一层工厂，所有的工厂都是此工厂的子类。而产生对象的类型由子类工厂决定。使用工厂方法来实现上面的加减乘除对象的创建
//定义上一级工厂店的接口
public interface IFractory {
public Operation generatOper();
}
//为每一个类创建工厂
/**
* 工厂方法 为每一个对象生成一个工厂类
*/
public class AddOperationFactory implements IFractory{
public Operation generatOper(){
return new AddOperation();
}
}public class SubOperationFactory implements IFractory{
public Operation generatOper(){
return new SubOperation();
}
}
public class MulOperationFactory implements IFractory{
public Operation generatOper(){
return new MulOperation();
}
}
public classDivOperationFactory implements IFractory{
public Operation generatOper(){
return new DivOperation();
}
}
//客户端代码
IFractory fractory =new AddOperationFactory();
Operation Operation = fractory .generatOper();
Operation.getResult(firstNum,secondNum);
工厂方法将类的实例化推迟到了其子类。所以使用工厂方法模式时，需要客户端决定实例化哪一个工厂类。选择判断问题还是存在的。也就是说，工厂方法把简单的工厂内部逻辑判断转移到了客户端来运行。你想要加的功能，本来是要改工厂类的，而现在是修改客户端。不过，我们在某些情况下通过工厂方法，只需要修改一行实例化的代码就可以实现系统元素的切换(比如切换数据源)。这也是很方便的。
工厂方法模式Factory Method，又称 多态性工厂模式。在工厂方法模式中，核心的工厂类不再负责所有的产品的创建，而是将具体创建的工作交给子类去做。该核心类成为一个抽象工厂角色，仅负责给出具体工厂子类必须实现的接口，而不接触哪一个产品类应当被实例化这种细节。
2.定义：
工厂方法模式是简单工厂模式的衍生，解决了许多简单工厂模式的问题。首先完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。
3.延伸：
在上面简单工厂的引入中，我们将实例化具体对象的工作全部交给了专门负责创建对象的工厂类(场务)中，这样就可以在我们得到导演的命令后创建对应的车(产品)类了。但是剧组的导演是性情比较古怪的，可能指令也是无限变化的。这样就有了新的问题，一旦导演发出的指令时我们没有预料到的，就必须得修改源代码。这也不是很合理的。工厂方法就是为了解决这类问题的。
工厂方法的优点/缺点：
抽象工厂：
提供一个创建一系列相关相互依赖对象的接口，而无需指定他们具体的类。抽象工厂为不同产品族的对象创建提供接口。
使用场景：系统需要在不同产品族进行切换
代码实现：
import MulOperationFactory.IDepartment;
//不同产品组使用一个工厂
public class SalServerFactory implements IFacfory {
public IUser createUser(){
return new SqIServerUser();
}
}public IDepartment createDepartment(){
return new SqIServerDepartment();
}
public class AccessFactory implements IFacfory{
public IUser createUser(){
return new AccessUser();
public IDepartment createDepartment(){
return new AccessDepartment();
}
客户端:
IFacfory facfory = new AccessFactory();
IUser user = facfory. createUser();
IDepartment department = facfory. createDepartment();
user.insert();
user.getById();
department.insert();
department.getDepartmentById();
第一个抽象工厂最大的好处就是便于交换产品系列，具体工厂在代码中一般只出现一次。这就使得改变应用的具体工厂很容易。
第二个好处是他能让具体的创建对象实例和客户端分离，客户端是通过他们的抽象接口操作实例
抽象工厂不太易于拓展，如果需要自增功能，或者自增产品，则需要至少修改三个类，而且实例化的代码是写死在程序中的
， 这样无法避免违背开放-关闭原则。
对于上述问题，可以通过配置文件，结合反射的方式来解决。
抽象工厂：定义
为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
抽象工厂的优点/缺点：
标签：编程语言 ber 切换 交换 ann default art 迪米特法则 静态
原文地址：https://www.cnblogs.com/xiaoxiao1016/p/9895414.html
