工厂模式（简单工厂+工厂方法+抽象工厂）

一、简单工厂模式

       “简单工厂模式”，也就是说，到底要实例化谁，将来会不会增加实例化的对象，将来会不会增加实例化的对象，比如增加开根运算，这是很容易变化的地方，考虑用一个单独的类来做这个创造实例的过程，这就是工厂。

        简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。

        简单运算工厂实例，以计算器的加减乘除为例子：

//运算类
public class Operation {

private double _numberA = 0;
private double _numberB = 0;

public double get_numberA() {
return _numberA;
}
public double get_numberB() {
return _numberB;
}
public void set_numberA(double _numberA) {
this._numberA = _numberA;
}
public void set_numberB(double _numberB) {
this._numberB = _numberB;
}
public double getResult() {
double result = 0d;
return result;
}
}

//加减乘除类

public class Add extends Operation {
public double getResult(){
double result = 0;
result = get_numberA() + get_numberB();
System.out.println("相加："+result);
return result;
}
}

public class Sub extends Operation {
public double getResult(){
double result = 0;
result = get_numberA() - get_numberB();
System.out.println("相減："+result);
return  result;
}
}

public class Mul extends Operation {
public double getResult(){
double result = 0;
result = get_numberA() * get_numberB();
System.out.println("相乘："+result);
return  result;
}
}

public class Div extends Operation {
public double getResult() {
double result = 0;
if (get_numberB() == 0)
try {
throw new Exception("除數不能為0!");
} catch (Exception e) {
e.printStackTrace();
}
result = get_numberA() / get_numberB();
System.out.println("相除："+result);
return  result;
}
}

//实例化对象的工厂类
public class OperationFactory {
public static Operation createOperate(String operate){
Operation oper = null;
switch (operate){
case "+" :
oper = new Add();
break;
case "-" :
oper = new Sub();
break;
case "*" :
oper = new Mul();
break;
case "/" :
oper = new Div();
break;
}
return oper;
}
}

//测试类
public class test {
public static void main(String[] args){
Operation oper;
oper = OperationFactory.createOperate("+");
oper.set_numberA(1);
oper.set_numberB(2);
Double result = oper.getResult();
}
}

二、工厂方法模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂方法使一个类的实例化延迟到其子类。主要解决：主要解决接口选择的问题。何时使用：我们明确地计划不同条件下创建不同实例时。如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。关键代码：创建过程在其子类执行。特点：一个工厂接口，可以生产多个具体实体类例如：//工厂接口
public interface IFactory {
Operation CreateOperation();
}//加法类实体类
public class AddFactory implements IFactory {
@Override
public Operation CreateOperation() {
return new Add();
}
}

//减法类实体类
public class SubFactory implements IFactory {
@Override
public Operation CreateOperation() {
return new Sub();
}
}

//乘法实体类
public class MulFactory implements IFactory {
@Override
public Operation CreateOperation() {
return new Mul();
}
}

//除法实体类
public class DivFactory implements IFactory {
@Override
public Operation CreateOperation() {
return new Div();
}
}

//测试类
public class Test {
public static void main(String[] args){
IFactory operFactory = new AddFactory();
Operation oper = operFactory.CreateOperation();
oper.set_numberA(1);
oper.set_numberB(2);
double result = oper.getResult();
}
}

拓展：

使用反射机制可以解决每次增加一个产品时，都需要增加一个对象实现工厂的缺点：

public class ClassFactory {
public static Object getClass(Class<AddFactory> clazz){
Object obj = null;
try{
obj = Class.forName(clazz.getName()).newInstance();
}catch (Exception e){
e.printStackTrace();
}
return  obj;
}
}

//测试类
public class Test {
public static void main(String[] args){
IFactory operFactory = new AddFactory();
Operation oper = operFactory.CreateOperation();
oper.set_numberA(1);
oper.set_numberB(2);
double result = oper.getResult();

IFactory operFactory2 = (AddFactory)ClassFactory.getClass(AddFactory.class);
Operation oper2 = operFactory.CreateOperation();
oper2.set_numberA(3);
oper2.set_numberB(4);
double result2 = oper2.getResult();
}
}

三、抽象工厂模式

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象
意图：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。主要解决：主要解决接口选择的问题。何时使用：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。如何解决：在一个产品族里面，定义多个产品。关键代码：在一个工厂里聚合多个同类产品。特点：多个工厂接口，一个接口可以生产多个具体实体类。例如：使用sqserver 和 access 分别添加和根据id查询用户和部门。//用户接口
public interface IUser {
void Insert(User user);
User GetUser(int id);
}

//部门接口
public interface IDepartment {
void Insert(Department department);
Department GetDepartment(int id);
}

//access操作用户实例类
public class AccessUser implements IUser {
@Override
public void Insert(User user) {
System.out.println("在Access中给User表添加一条记录！");
}
@Override
public User GetUser(int id) {
System.out.println("在Access中根据Id从User一条记录！");
return null;
}
}

//sqlserver操作用户实例类
public class SqlserverUser implements IUser {
@Override
public void Insert(User user) {
System.out.println("在Sqlserver中給User添加一条记录！");
}
@Override
public User GetUser(int id) {
System.out.println("在Sqlserver中根据Id得到一条记录！");
return null;
}
}

//access操作部门实例类
public class AccessDepartment implements IDepartment {
@Override
public void Insert(Department department) {
System.out.println("在Access中给department表增加一条记录！");
}
@Override
public Department GetDepartment(int id) {
System.out.println("在Access中根据Id得到department表中一条记录！");
return null;
}
}

//sqlserver操作部门实例类
public class SqlserverDepartment implements IDepartment {
@Override
public void Insert(Department department) {
System.out.println("在sqlserver中给department表增加一条记录！");
}
@Override
public Department GetDepartment(int id) {
System.out.println("在sqlserver中根据Id得到department表中一条记录！");
return null;
}
}

//创建抽象类来获取工厂
interface IFactory {
IUser CreateUser();
IDepartment CreateDepartmen();
}

//创建扩展了 IFactory 的工厂类，基于给定的信息生成实体类的对象
public class AccessFactory implements IFactory {
@Override
public IUser CreateUser() {
return new AccessUser();
}
@Override
public IDepartment CreateDepartmen() {
return new AccessDepartment();
}
}

//sqlserv工厂实例
public class SqlServerFactory implements  IFactory {
@Override
public IUser CreateUser() {
return new SqlserverUser();
}

@Override
public IDepartment CreateDepartmen() {
return new SqlserverDepartment();
}
}

//测试类
public class test {
public static void main(String[] args){
User user = new User();
Department department = new Department();
IFactory factory = new SqlServerFactory();

IUser iu = factory.CreateUser();
iu.Insert(user);
iu.GetUser(1);

IDepartment idp = factory.CreateDepartmen();
idp.Insert(department);
idp.GetDepartment(1);
}
}