设计模式——抽象工厂模式
设计模式——抽象工厂模式
(1）目的：创建一系列产品时，无需指定它们具体的类。
（2）如何实现：
1.实现同一功能的具体产品类（ProductA1）继承于同一个基类抽象产品接口类（AbstractProductA），在基类中定义虚函数接口，由具体产品类实现。
2.具体工厂类（ConcreteFactory1）继承于同一个基类抽象工厂接口类（AbstractFactory），在基类中包含所有产品创建的抽象方法，由具体工厂类实现。
（3）优点：
1.改变为不同的具体工厂即可使用不同的产品配置，使具体依赖于抽象，实现依赖倒置原则。
2.客户端没有使用具体的产品或者具体的工厂，实现了解耦的目的。
（4）缺点：
1.每当新增一个新产品时，要在具体工厂类和具体产品类中各新增一个类，开发量较大。
2.具体实例化哪一个工厂交给客户端去判断。
│ access_database.cpp
│ access_database.h
│ factory.cpp
│ factory.h
│ i_product.cpp
│ i_product.h
│ i_user.cpp
│ i_user.h
│ main.cpp
│ product.cpp
│ product.h
│ product_access.cpp
│ product_access.h
│ product_sql.cpp
│ product_sql.h
│ sql_database.cpp
│ sql_database.h
│ user.cpp
│ user.h
│ user_access.cpp
│ user_access.h
│ user_sql.cpp
│ user_sql.h
user.h
#pragma once
#include
using namespace std;
class User
{
private:
int id;
std::string name;
public:
bool SetID(int);
int ID();
bool SetName(std::string);
std::string Name();
}; user.cpp
#include "user.h"
bool User::SetID(int tem)
{
id = tem;
return 0;
}
int User::ID()
{
return id;
}
bool User::SetName(std::string tem)
{
name = tem;
return 0;
}
std::string User::Name()
{
return name;
}i_user.h（AbstractProductA）
#pragma once
#include "user.h"
class IUser
{
public:
void virtual InsertUser(User)=0;
void virtual GetUser()=0;
};
i_user.cpp
#include "i_user.h"
user_sql.h（ProductA1）
#pragma once
#include "i_user.h"
class UserSql :
public IUser
{
void InsertUser(User);
void GetUser();
};
user_sql.cpp
#include "user_sql.h"
#include
void UserSql::InsertUser(User)
{
cout << "向sql中插入用户" << endl;
}
void UserSql::GetUser()
{
cout << "向sql中获取所有用户" << endl;
} user_access.h（ProductA2）
#pragma once
#include "i_user.h"
class UserAccess :
public IUser
{
public:
void InsertUser(User);
void GetUser();
};
user_access.cpp
#include "user_access.h"
#include
void UserAccess::InsertUser(User)
{
cout << "向access中插入用户" << endl;
}
void UserAccess::GetUser()
{
cout << "向access中获取所有用户" << endl;
} product.h
#pragma once
#include
using namespace std;
class Product
{
private:
int id=0;
public:
bool SetID(int);
int ID();
};
product.cpp
#include "product.h"
bool Product::SetID(int tem)
{
id = tem;
return 0;
}
int Product::ID()
{
return id;
}i_product.h（AbstractProductB）
#pragma once
#include "product.h"
class IProduct
{
public:
void virtual InsertProduct(Product) = 0;
void virtual GetProduct() = 0;
};
i_product.cpp
#include "i_product.h"
product_sql.h（ProductB1)
#pragma once
#include
#include "i_product.h"
class ProductSql :
public IProduct
{
public:
void InsertProduct(Product);
void GetProduct();
};
product_sql.cpp
#include "product_sql.h"
void ProductSql::InsertProduct(Product)
{
std::cout << "向sql中插入一个Product" << endl;
}
void ProductSql::GetProduct()
{
std::cout << "向sql获取Product" << endl;
}product_access.h（ProductB2)
#pragma once
#include
#include "i_product.h"
class ProductAccess :
public IProduct
{
public:
void InsertProduct(Product);
void GetProduct();
};
product_access.cpp
#include "product_access.h"
void ProductAccess::InsertProduct(Product tem)
{
std::cout << "向access中插入一个Product" << endl;
}
void ProductAccess::GetProduct()
{
std::cout << "向access获取Product" << endl;
}factory.h（AbstractFactory）
#pragma once
#include
using namespace std;
class Product
{
private:
int id=0;
public:
bool SetID(int);
int ID();
};
factory.cpp
#include "factory.h"
sql_database.h（ConcreteFactory1）
#pragma once
#include "factory.h"
class SqlDatabase :
public Factory
{
public:
IUser* CreateUser();
IProduct* CreateProduct();
};
sql_database.cpp
#include "sql_database.h"
IUser* SqlDatabase::CreateUser()
{
return new UserSql();
}
IProduct* SqlDatabase::CreateProduct()
{
return new ProductSql();
}access_database.h（ConcreteFactory2）
#pragma once
#include "factory.h"
class AccessDatabase :
public Factory
{
public:
IUser* CreateUser();
IProduct* CreateProduct();
};
access_database.cpp
#include "access_database.h"
IUser* AccessDatabase::CreateUser()
{
return new UserAccess();
}
IProduct* AccessDatabase::CreateProduct()
{
return new ProductAccess();
}main.cpp
#include
#include "sql_database.h"
#include "access_database.h"
int main()
{
Factory* sql_database = new SqlDatabase();
Factory* access_database = new AccessDatabase();
IUser* user1 = sql_database->CreateUser();
IUser* user2 = access_database->CreateUser();
IProduct* product1 = sql_database->CreateProduct();
IProduct* product2 = access_database->CreateProduct();
User tem;
Product tem1;
user1->InsertUser(tem);
user2->InsertUser(tem);
product1->InsertProduct(tem1);
product2->InsertProduct(tem1);
}