设计模式（二）工厂模式

**工厂模式：**主要是为创建对象提供了接口，主要分为三类：简单工厂模式(Simple Factory) 、工厂方法模式(Factory Method) 、抽象工厂模式(Abstract Factory)

使用工厂模式的两种情况：
（1）在编码时不能预见需要创建哪种类的实例。
（2）系统不应依赖于产品类实例如何被创建、组合和表达的细节

一、简单工厂模式

简单工厂模式又叫静态工厂方法模式（Static FactoryMethod Pattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

实现了算法和界面的分离，也就是将业务逻辑和界面逻辑分开了，降低了耦合度。
算法的封装：定义一个抽象的算法接口，提供不同算法的公共接口方法。简单工厂将对象的创建过程进行了封装，用户不需要知道具体的创建过程，只需要调用工厂类获取对象即可。
简单工厂类：作为一个独立的类，实现了针对不同的算法进行实例化。

例子：面试题：使用java实现一个计算机控制台程序，要求输入数的运算，得到结果。 

public abstract class Operation {

    public abstract float getResult(float firstNumber, float secondNumber);

}
//把符号都当做对象处理，实现此接口
public class AddOperation extends Operation {
    @Override
    public float getResult(float firstNumber, float secondNumber) {
        return firstNumber+secondNumber;
    }

}
public class SubOperation extends Operation {
    @Override
    public float getResult(float firstNumber, float secondNumber) {
        return firstNumber-secondNumber;
    }
}
public class MulOperation extends Operation {
    @Override
    public float getResult(float firstNumber, float secondNumber) {
        return firstNumber*secondNumber;
    }
}
public class DivOperation extends Operation {
    @Override
    public float getResult(float firstNumber, float secondNumber) {
        return firstNumber/secondNumber;
    }
}

//接下来需要解决的就是对象的创建问题了，既如何根据不同的情况创建不同的对象：我们正好可以通过简单工厂模式实现
public class OperationFactory {

    public static Operation getOperation(String quotaFlag){
        Operation o = null;
        switch (quotaFlag){
            case "+" :  o = new AddOperation(); break;
            case "-" :  o = new SubOperation(); break;
            case "*" :  o = new MulOperation(); break;
            case "/" :  o = new DivOperation(); break;
            default:break;
        }
        return o;
    }
}
//调用：
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();
        System.out.println(count(firstNum,secondNum,countQuato));
    }
    private static float count(float firstNum,float secondNum , String countQuota){
    //通过工厂类获取对象
        Operation operation = OperationFactory.getOperation(countQuota);
        return operation.getResult(firstNum,secondNum);
    }
}

这种简单工厂的写法是通过switch-case来判断对象创建过程的。在实际使用过程中，违背了 开放-关闭原则，当然有些情况下可以通过反射调用来弥补这种不足。

二、工厂模式

工厂方法 定义一个用于创建对象的接口，让子类决定实例化哪一个类，工厂方法使得一个类的实例化延迟到了子类

工厂方法在简单工厂的基础上再包了一层工厂，所有的工厂都是此工厂的子类。而产生对象的类型由子类工厂决定。使用工厂方法来实现上面的加减乘除对象的创建。

//定义上级工厂的接口
public interface IFractory {
    public Operation generateOper();
}
//为每一个类创建工厂
/**
 * 工厂方法  为每个对象生成一个工厂类
 */
public class AddOperationFactory implements IFractory{

    @Override
    public Operation generateOper() {
        return new AddOperation();
    }
}
public class SubOperationFactory implements IFractory {
    @Override
    public Operation generateOper() {
        return new SubOperation();
    }
}
public class MulOperationFactory implements IFractory {
    @Override
    public Operation generateOper() {
        return new MulOperation();
    }
}
public class DivOperationFactory implements IFractory {
    @Override
    public Operation generateOper() {
        return new DivOperation();
    }
}
//客户端代码
IFractory fractory = new AddOperationFactory();
Operation operation = fractory.generateOper();
operation.getResult(firstNum,secondNum);

工厂方法将类的实例化推迟到了其子类。所以使用工厂方法模式时，需要客户端决定实例化哪一个工厂类。选择判断问题还是存在的。也就是说，工厂方法把简单的工厂内部逻辑判断转移到了客户端来运行。你想要加的功能，本来是要改工厂类的，而现在是修改客户端。不过，我们在某些情况下通过工厂方法，只需要修改一行实例化的代码就可以实现系统元素的切换(比如切换数据源)。这也是很方便的。

三、抽象工厂
提供一个创建一系列相关相互依赖对象的接口，而无需指定他们具体的类。抽象工厂为不同产品族的对象创建提供接口。
使用场景：系统需要在不同产品族进行切换

public interface IFacfory {
    public IUser createUser();
    public IDepartment createDepartment();
}
public interface IUser {
    public void insert();
    public void getById();
}
public interface IDepartment {
    public void insert();
    public void getDepartmentById();
}
public class SqlServerUser implements IUser {
    @Override
    public void insert() {
        System.out.println("insert into sqlserver.");
    }

    @Override
    public void getById() {
        System.out.println("get user by id from sqlserver.");
    }
}
public class SqlServerDepartment implements IDepartment {
    @Override
    public void insert() {
        System.out.println("insert department into sqlserver.");
    }

    @Override
    public void getDepartmentById() {
        System.out.println("get department in sqlserver by id.");
    }
}

public class AccessUser implements IUser {
    @Override
    public void insert() {
        System.out.println("insert into access");
    }

    @Override
    public void getById() {
        System.out.println("get by id from access");
    }
}
public class AccessDepartment implements IDepartment {
    @Override
    public void insert() {
        System.out.println("insert department into sqlserver.");
    }

    @Override
    public void getDepartmentById() {
        System.out.println("get department in sqlserver by id.");
    }
}

//不同产品组使用一个工厂
public class SqlServerFactory implements IFacfory {
    @Override
    public IUser createUser() {
        return new SqlServerUser();
    }

    @Override
    public IDepartment createDepartment() {
        return new SqlServerDepartment();
    }
}
public class AccessFactory implements IFacfory {
    @Override
    public IUser createUser() {
        return new AccessUser();
    }

    @Override
    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();

抽象工厂最大的好处就是便于交换产品系列，具体工厂在代码中一般只出现一次。这就使得改变应用的具体工厂很容易。
第二个好处是他能让具体的创建对象实例和客户端分离，客户端是通过他们的抽象接口操作实例
抽象工厂不太易于拓展，如果需要自增功能，或者自增产品，则需要至少修改三个类，而且实例化的代码是写死在程序中的 ， 这样无法避免违背开放-关闭原则。
对于上述问题，可以通过配置文件，结合反射的方式来解决。

四、简单工厂与工厂模式的异同点
相同点：都集中封装了对象的创建，使得要更换对象时不需要做大的改动就可实现，降低了客户端程序与产品对象的耦合。

不同点：
（1）工厂模式的优点：
工厂模式是简单工厂模式的进一步抽象和推广。它遵循了“开放—封闭”原则。
（2）简单工厂模式的优点：
简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。
（3）工厂模式的缺点：
工厂方法把简单工厂的内部逻辑判断转移到了客户端代码来执行；每增加一产品就要增加一个产品工厂的类，增加了额外的开发量。
（4）简单工厂的缺点：
是没有遵守开放—封闭原则。所谓的“开放-封闭”原则就是开放接口，封闭修改。如果将来需要添加一个开方的算法，那么，在简单工厂模式中，就必须在简单工厂类中添加相应的判断语句！另外，在简单工厂类中利用了Switch语句，这对程序的扩展本身就不不利。

五、工厂模式与抽象工厂比较
只有一个User类和User操作类的时候，只需要工厂方法模式； 但数据库中有很多的表，而Sql和access又是两大不同的分类，所以就延伸到了抽象工厂模式

抽象工厂模式的优点：

1、易于交换产品系列，由于具体工厂类，在一个应用程序中只需要在初始化的时候出现一次， 这就使得改变一个应用的具体工厂变得非常容易，它只需改变具体工厂即可使用不同的产品配置。

2、它让具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户端代码中。

抽象模式的缺点：
1、抽象模式虽然便于两数据库之间的切换，但是不便于增加需求功能。
2、如果有100个调用数据库访问的类，就需要多次实例化100此具体工厂类。