一、工厂方法

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

1、工厂法法模式结构图：

工厂方法抽象出一个工厂接口，这个接口只有一个方法，就是创建抽象产品的工厂方法，所有要生产具体类的工厂就去实现这个接口。当需要创建新对象的工厂时，就不需要更改原有的工厂类，只需要增加相应的工厂类。

产品抽象类 Product

public abstract class Product {
    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

具体产品类 ConcreteProductA

public class ConcreteProductA extends Product{

    public ConcreteProductA(){
        super();
        this.name = "具体产品 A";
    }
}

具体产品类 ConcreteProductB

public class ConcreteProductB extends Product{

    public ConcreteProductB(){
        super();
        this.name = "具体产品 B";
    }
}

抽象工厂接口 Factory

public interface Factory {
    public Product createProduct();
}

创建 ConcreteProductA 的工厂类 ConcreteProductAFactory

public class ConcreteProductAFactory implements Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

创建 ConcreteProductB 的工厂类 ConcreteProductBFactory

public class ConcreteProductBFactory implements Factory{
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

效果测试类

public class FactoryMethodTest {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteProductAFactory();
        Factory factoryB = new ConcreteProductBFactory();
        Product productA = factoryA.createProduct();
        Product productB = factoryB.createProduct();

        System.out.println(productA.getName());
        System.out.println(productB.getName());
    }
}

2、工厂方法模式的优缺点

工厂方法模式具有良好的封装性，代码结构清晰。如果一个调用者需要一个具体的产品对象，只要知道这个产品的类名，不用知道创建对象的艰辛过程，降低模块间的耦合，并且拓展性好。但缺点也是相对的，每增加一个产品，就需要加一个产品的工厂类，增加了额外的开发量。

二、抽象工厂模式

抽象工厂模式定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

1、抽象工厂模式结构图

AbstractProductA 和 AbstractProductB 是两个抽象产品，而ProductA1和ProductA2、ProductB1、ProductB2就是对两个抽象产品的具体实现。

AbstractFactory是一个抽象工厂接口，它里面包含所有产品创建的抽象方法。而ConcreteFactory1 和ConcreteFactory2就是具体的工厂了。

抽象产品类 AbstractProductA

public abstract class AbstractProductA {
    protected String type = "A型产品";

    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /** 每个产品具体实现该方法 */
    public abstract void doSomething();
}

抽象产品类 AbstractProductB

public abstract class AbstractProductB {
    protected String type = "B型产品";

    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /** 每个产品具体实现该方法 */
    public abstract void doSomething();
}

A型具体产品 ProductA1

public class ProductA1 extends AbstractProductA{

    public ProductA1(){
        super();
        this.name = "产品A1";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

A型具体产品 ProductA2

public class ProductA2 extends AbstractProductA{

    public ProductA2(){
        super();
        this.name = "产品A2";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

B型具体产品 ProductB1

public class ProductB1 extends AbstractProductB{

    public ProductB1(){
        super();
        this.name = "产品B1";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

B型具体产品 ProductB2

public class ProductB2 extends AbstractProductB{

    public ProductB2(){
        super();
        this.name = "产品B2";
    }
    @Override
    public void doSomething() {
        System.out.println(this.name + " doSomething");
    }
}

抽象工厂接口 AbstractFactory

public interface AbstractFactory {

    public AbstractProductA createProductA();

    public AbstractProductB createProductB();
}

创建1系列产品的工厂类 ConcreteFactory1

public class ConcreteFactory1 implements AbstractFactory{
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

创建2系列产品的工厂类 ConcreteFactory2

public class ConcreteFactory2 implements AbstractFactory{
    @Override
    public AbstractProductA createProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB2();
    }
}

效果测试类

public class AbstractFactoryTest {
    public static void main(String[] args) {
        AbstractFactory factory = new ConcreteFactory1();

        AbstractProductA productA = factory.createProductA();
        AbstractProductB productB = factory.createProductB();
        productA.doSomething();
        productB.doSomething();

        System.out.println("=========切换产品系列工厂=========");

        factory = new ConcreteFactory2();
        productA = factory.createProductA();
        productB = factory.createProductB();
        productA.doSomething();
        productB.doSomething();
    }

}

输出：
产品A1 doSomething
产品B1 doSomething
=切换产品系列工厂=
产品A2 doSomething
产品B2 doSomething

由此可见，切换工厂类，即可对获取的产品系列进行切换

2、抽象工厂模式的优缺点

抽象工厂最大的好处是便于切换产品系列，其次是它让具体的创建实例过程与客户端分离，客户端是通过抽象接口获取实例，依赖的产品也是抽象的，而不是具体的产品类。

抽象工厂的缺点是产品族的拓展非常困难，如果增加了一个产品，抽象工厂类中需要增加创建该产品的抽象方法，具体工厂类中也得去实现，涉及到的改动多。

前言

在学习侯捷老师的有关设计模式的课程(李建忠老师主讲)中，老师对23种设计模式的有自己的划分，如下。所以老师讲解是按照这种顺序讲解。

对象创建：

Abstract Factory设计模式

1.模式的应对场景

和工厂模式不同，它解决的是单一的对象创建工作。抽象工厂模式解决的是“一系列相互依赖的对象”的创建工作。

设计模式之工厂模式(Factor Method)

2.案例1：数据库的connection、command依赖

先给代码再说明：

#include <iostream>
#include <string>
using namespace std;


//database connection
class IDBConnection
{
public:
	virtual void ConnectionString() = 0;
};

class SqlConnection : public IDBConnection
{
public:
	void ConnectionString(){ cout << "Sql connection" << endl; }
};
class MysqlConnection : public IDBConnection
{
public:
	void ConnectionString(){ cout << "Mysql connection" << endl; }
};


//database command
class IDBCommand
{
public:
	virtual void CommandText() = 0;
	virtual void SetConnection(IDBConnection* connect) = 0;
};

class SqlCommand : public IDBCommand
{
public:
	void CommandText(){ cout << "Sql command text" << endl; }
	void SetConnection(IDBConnection* connect){ cout << "set connection with "; connect->ConnectionString(); }
};
class MysqlCommand : public IDBCommand
{
public:
	void CommandText(){ cout << "Mysql command text" << endl; }
	void SetConnection(IDBConnection* connect){ cout << "set connection with "; connect->ConnectionString(); }
};


/***********工厂介入 start*****************************/

//抽象工厂
class IDBFactor
{
public:
	virtual IDBConnection* creatDBConnection() = 0;
	virtual IDBCommand* creatDBCommand() = 0;
};
//sql 工厂
class SqlFactor : public IDBFactor
{
public:
	virtual IDBConnection* creatDBConnection()
	{
		return new SqlConnection;
	}
	virtual IDBCommand* creatDBCommand()
	{
		return new SqlCommand;
	}
};
//Mysql 工厂
class MysqlFactor : public IDBFactor
{
public:
	virtual IDBConnection* creatDBConnection()
	{
		return new MysqlConnection;
	}
	virtual IDBCommand* creatDBCommand()
	{
		return new MysqlCommand;
	}
};

/***********工厂介入 end*****************************/


class EmployeeDAO
{
	IDBFactor* dbfactor;
public:
	EmployeeDAO(){}
	EmployeeDAO(IDBFactor* _dbfactor) : dbfactor(_dbfactor){}

	void GetEmployees(){

	//IDBConnection* connection = new SqlConnection();
	IDBConnection* connection = dbfactor->creatDBConnection();
	connection->ConnectionString();

	//IDBCommand* command = new SqlCommand();
	IDBCommand* command = dbfactor->creatDBCommand();
	command->CommandText();
	command->SetConnection(connection);
	}
};

int main()
{
	EmployeeDAO e(new MysqlFactor);
	e.GetEmployees();

	EmployeeDAO e1(new SqlFactor);
	e1.GetEmployees();

	system("pause");
	return 0;
}

EmployeeDAO类中，由于Connection和Command是相互依赖，所以我们把这两个对象的创建放在一个抽象工厂IDBFactor，然后分别有SqlFactor 和MysqlFactor 两个具体工厂，各自创建自己的Connection和Command（SqlConnection、SqlCommand和MysqlConnection、MysqlCommand）相关类。

使用工厂模式的影响：
如果用工厂模式分别生成这两个对象，那么可能会存在这样一种情况：即我们生成了一个SqlConnection，但是command却是MysqlCommand，代码如下：

#if 1
#include <iostream>
#include <string>
using namespace std;


//database connection
class IDBConnection
{
public:
	virtual void ConnectionString() = 0;
};
class SqlConnection : public IDBConnection
{
public:
	void ConnectionString(){ cout << "Sql connection" << endl; }
};
class MysqlConnection : public IDBConnection
{
public:
	void ConnectionString(){ cout << "Mysql connection" << endl; }
};


/***connection工厂***/
class IDBConnectionFactor
{
public:
	virtual IDBConnection* creatorIDBConnection() = 0;
};
class SqlConnectionFactor : public IDBConnectionFactor
{
public:
	virtual IDBConnection* creatorIDBConnection(){ return new SqlConnection; }
};
class MySqlConnectionFactor : public IDBConnectionFactor
{
public:
	virtual IDBConnection* creatorIDBConnection(){ return new MysqlConnection; }
};
/***connection工厂***/


//database command
class IDBCommand
{
public:
	virtual void CommandText() = 0;
	virtual void SetConnection(IDBConnection* connect) = 0;
};
class SqlCommand : public IDBCommand
{
public:
	void CommandText(){ cout << "Sql command text" << endl; }
	void SetConnection(IDBConnection* connect){ cout << "Sql set connection with "; connect->ConnectionString(); }
};
class MysqlCommand : public IDBCommand
{
public:
	void CommandText(){ cout << "Mysql command text" << endl; }
	void SetConnection(IDBConnection* connect){ cout << "Mysql set connection with "; connect->ConnectionString(); }
};

/***Command工厂***/
class IDBCommandFactor
{
public:
	virtual IDBCommand* creatorIDBCommand() = 0;
};
class SqlCommandFactor : public IDBCommandFactor
{
public:
	virtual IDBCommand* creatorIDBCommand(){ return new SqlCommand; }
};
class MySqlCommandFactor : public IDBCommandFactor
{
public:
	virtual IDBCommand* creatorIDBCommand(){ return new MysqlCommand; }
};
/***Command工厂***/


class EmployeeDAO
{
	IDBConnectionFactor* connectionfactor;
	IDBCommandFactor* commandfactor;
public:
	EmployeeDAO(){}
	EmployeeDAO(IDBConnectionFactor* _connectionfactor, IDBCommandFactor* _commandfactor)
		: connectionfactor(_connectionfactor), commandfactor(_commandfactor){}

	void GetEmployees(){

		//IDBConnection* connection = new SqlConnection();
		IDBConnection* connection = connectionfactor->creatorIDBConnection();
		connection->ConnectionString();

		//IDBCommand* command = new SqlCommand();
		IDBCommand* command = commandfactor->creatorIDBCommand();
		command->CommandText();
		command->SetConnection(connection);
	}
};

int main()
{
	EmployeeDAO e(new SqlConnectionFactor, new MySqlCommandFactor);
	e.GetEmployees();

	system("pause");
	return 0;
}
#endif

这里就会有两个工厂数据成员，在客户使用EmployeeDAO类时，就可能出现下图中创建对象不搭配的情况。

3.产品族和产品等级

李建忠老师在讲解抽象工厂模式时，并没有提到关于产品族和产品等级这个概念，但是我发现网上很多关于抽象工厂的文章中都提到了这个概念，所以在这里稍微说一下我的理解。

拿案例1举例，我们可以做这样的一个划分：

如果我们增加一个产品族，程序是可以很好扩展，不会违背开闭原则；但是如果我们增加一个产品等级，你会发现就需要修改而不是扩展代码，会违背开闭原则。

这里你可能会比较难区分什么是产品族？什么是产品等级？我的理解就是：
因为抽象工厂模式解决的就是“一系列相互依赖的对象”的创建工作，所以这系列对象就是一个产品族，不是一族怎么会相互依赖呢！

4.案例2

下面在举一个例子，如下所示是产品族和产品等级。
图片来源：链接

假设我们的客户程序是先打开手机和路由器，再通过手机控制路由器，伪代码如下;

class Client
{
public:
	void getWorking(){
		generate 手机;
		手机start;
		generate 路由器;
		路由器start;
		手机控制路由器;
	}
}

代码还是很简单写的，下面一步步写：

下面开始代码：
1.先来写华为手机和路由器的类+Client类并做简单测试（不用抽象工厂模式）

#include <iostream>
#include <string>
using namespace std;

//手机基类
class IPhone
{
public:
	virtual void phoneStart() = 0;
	virtual string phoneName() = 0;
};
class HuaweiPhone : public IPhone
{
public:
	virtual void phoneStart()
	{
		cout << "华为手机开机" << endl;
	}
	virtual string phoneName()
	{
		return string("华为");
	}
};

//路由器基类
class IRouter
{
public:
	virtual void routerStart() = 0;
	virtual void control(IPhone* _phone) = 0;

};
class HuaweiRouter : public IRouter
{
public:
	virtual void routerStart()
	{
		cout << "华为路由器开机" << endl;
	}
	virtual void control(IPhone* _phone)
	{
		cout << "华为路由器被" << _phone->phoneName()<<"手机控制"<< endl;
	}
};


//客户
class Client
{
public:
	void getWorking()
	{
		IPhone* phone = new HuaweiPhone;
		phone->phoneStart();
		IRouter* router = new HuaweiRouter;
		router->routerStart();

		router->control(phone);
	}
};


int main()
{
	Client c;
	c.getWorking();


	system("pause");
	return 0;
}

2.扩展出小米手机和路由器的类+加入抽象工厂模式

#include <iostream>
#include <string>
using namespace std;

//手机基类
class IPhone
{
public:
	virtual void phoneStart() = 0;
	virtual string phoneName() = 0;
};
class HuaweiPhone : public IPhone
{
public:
	virtual void phoneStart()
	{
		cout << "华为手机开机" << endl;
	}
	virtual string phoneName()
	{
		return string("华为");
	}
};
class XiaomiPhone : public IPhone
{
public:
	virtual void phoneStart()
	{
		cout << "小米手机开机" << endl;
	}
	virtual string phoneName()
	{
		return string("小米");
	}
};



//路由器基类
class IRouter
{
public:
	virtual void routerStart() = 0;
	virtual void control(IPhone* _phone) = 0;

};
class HuaweiRouter : public IRouter
{
public:
	virtual void routerStart()
	{
		cout << "华为路由器开机" << endl;
	}
	virtual void control(IPhone* _phone)
	{
		cout << "华为路由器被" << _phone->phoneName()<<"手机控制"<< endl;
	}
};
class XiaomiRouter : public IRouter
{
public:
	virtual void routerStart()
	{
		cout << "小米路由器开机" << endl;
	}
	virtual void control(IPhone* _phone)
	{
		cout << "小米路由器被" << _phone->phoneName() << "手机控制" << endl;
	}
};


/******抽象工厂介入 start******/
class IAbstractFactor
{
public:
	virtual IPhone* creatPhone() = 0;
	virtual IRouter* creatRouter() = 0;
};

//华为工厂
class HuaweiFactor : public IAbstractFactor
{
public:
	virtual IPhone* creatPhone() { return new HuaweiPhone; }
	virtual IRouter* creatRouter(){ return new HuaweiRouter; }
};

//小米工厂
class XiaomiFactor : public IAbstractFactor
{
public:
	virtual IPhone* creatPhone() { return new XiaomiPhone; }
	virtual IRouter* creatRouter(){ return new XiaomiRouter; }
};

/******抽象工厂介入 end******/



//客户
class Client
{
	IAbstractFactor* factor;
public:
	Client(IAbstractFactor* _factor) : factor(_factor){}
	void getWorking()
	{
		IPhone* phone = factor->creatPhone();
		phone->phoneStart();
		IRouter* router = factor->creatRouter();
		router->routerStart();

		router->control(phone);
	}
};


int main()
{
	Client c(new HuaweiFactor);
	c.getWorking();

	Client c1(new XiaomiFactor);
	c1.getWorking();

	system("pause");
	return 0;
}

5.模式定义

6.模式结构

一个工厂（ConcreteFactor1）生产一系列相互依赖的对象（ProductA1 ProductB1）。

7.要点总结

1. 如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的工厂完全可以。
2. “系列对象”指的是在某一特定系列下的对象之间有相互依赖、或作用的关系。不同系列的对象(就像案例一中的MysqlCommand、SqlConnection)之间不能相互依赖。
3. Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。（意思就是无法应对产品等级的增加）

抽象工厂模式练习

某软件公司要推出一款新的手机游戏软件，该软件支持IOS、Android和Windows Phone等多个智能手机操作系统平台,针对不同的手机操作系统，该游戏软件提供了不同的游戏操作控制类(OperationController)和游戏界面控制类(InterfaceController)，并提供的相应的工厂类来封装这些类的初始化过程。该软件要求具有较好的扩展性，以支持新的操作系统平台，为了满足上述要求，试采用抽象工厂模式对其进行设计。

（1）绘制抽象工厂模式结构视图

（2）给出实例类图并实现代码

package AbstractFactoryPattern;
/** * 抽象产品-游戏界面控制类 */
public interface Gj19IInterfaceController {
    public void Interface();
} 

package AbstractFactoryPattern;
/** * 具体产品-Android游戏界面控制类 */
public class Gj19AndroidInterfaceController implements Gj19IInterfaceController {
    @Override
    public void Interface() {
        System.out.println("Android游戏界面控制");
    }
}

package AbstractFactoryPattern;
/** * 具体产品-IOS游戏界面控制类 */
public class Gj19IOSInterfaceController implements Gj19IInterfaceController {
    @Override
    public void Interface() {
        System.out.println("IOS游戏界面控制");
    }
}

package AbstractFactoryPattern;
/** * 具体产品-WindowsPhone游戏界面控制类 */
public class Gj19WindowsPhoneInterfaceController implements Gj19IInterfaceController {
    @Override
    public void Interface() {
        System.out.println("WindowsPhone游戏界面控制");
    }
}

package AbstractFactoryPattern;
/** * 抽象产品-游戏操作控制类 */
public interface Gj19IOperationController {
    public void Operator();
}

package AbstractFactoryPattern;
/** * 具体产品-Andriod游戏操作控制类 */
public class Gj19AndroidOperationController implements Gj19IOperationController {
    @Override
    public void Operator() {
        System.out.println("Andriod游戏操作控制");
    }
}

package AbstractFactoryPattern;
/** * 具体产品-IOS游戏操作控制类 */
public class Gj19IOSOperationController implements Gj19IOperationController {
    @Override
    public void Operator() {
        System.out.println("IOS游戏操作控制");
    }
}

package AbstractFactoryPattern;
/** * 具体产品-WindowsPhone游戏操作控制类 */
public class Gj19WindowsPhoneOperationController implements Gj19IOperationController {
    @Override
    public void Operator() {
        System.out.println("WindowsPhone游戏操作控制");
    }
}

package AbstractFactoryPattern;
/** * 抽象工厂--游戏控制类 */
public interface Gj19GameController {
    //游戏操作控制
    public Gj19IOperationController OperationController();
    //游戏界面控制
    public Gj19IInterfaceController InterfaceController();
}

package AbstractFactoryPattern;
/** * 具体工厂--Android游戏控制类 */
public class AndroidController implements Gj19GameController {
    //Android游戏操作控制
    @Override
    public Gj19IOperationController OperationController() {
        return new Gj19AndroidOperationController();
    }
    //Android游戏界面控制
    @Override
    public Gj19IInterfaceController InterfaceController() {
        return new Gj19AndroidInterfaceController();
    }
}

package AbstractFactoryPattern;
/** * 具体工厂--IOS游戏控制类 */
public class IOSController implements Gj19GameController {
    //IOS游戏操作控制
    @Override
    public Gj19IOperationController OperationController() {
        return new Gj19IOSOperationController();
    }
    //IOS游戏界面控制
    @Override
    public Gj19IInterfaceController InterfaceController() {
        return new Gj19IOSInterfaceController();
    }
}

package AbstractFactoryPattern;
/** * 具体工厂-- WindowsPhone游戏控制类 */
public class WindowsPhoneController implements Gj19GameController {
    // WindowsPhone游戏操作控制
    @Override
    public Gj19IOperationController OperationController() {
        return new Gj19WindowsPhoneOperationController();
    }
    // WindowsPhone游戏界面控制
    @Override
    public Gj19IInterfaceController InterfaceController() {
        return new Gj19WindowsPhoneInterfaceController();
    }
}

package AbstractFactoryPattern;
/** * 测试抽象工厂模式 */
public class TestAbstractFactoryPattern {
    public static void main(String[] args) {
        Gj19GameController  gj19GameController;  //抽象工厂--游戏控制类
         Gj19IInterfaceController gj19IInterfaceController;  //游戏界面控制类
         Gj19IOperationController gj19IOperationController;  //游戏操作控制类
         gj19GameController = new AndroidController();  //具体工厂--Android游戏控制类
         gj19IInterfaceController = gj19GameController.InterfaceController();
         gj19IOperationController = gj19GameController.OperationController();
         gj19IInterfaceController.Interface();
         gj19IOperationController.Operator();
    }
}