工厂模式大体可以分为简单工厂模式、工厂方法模式和抽象工厂模式。
简单工厂模式
简单工厂方法可能是最常见的工厂类创建型模式了，其中有几个角色，一个是抽象产品角色，一个是具体产品角色，多个具体产品都可以抽象成同一个抽象产品。在简单工厂方法中，有一个专门的工厂类，根据不同的参数返回不同具体产品类的实例，这些具体产品可以抽象出同一个抽象产品。
#include <iostream>
enum class BallEnum { BasketBall = 1, SocketBall = 2 };
class Ball {
public:
Ball() {}
virtual ~Ball() {}
virtual void Play() {}
};
class BasketBall : public Ball {
public:
void Play() override { std::cout << "play basketball \n"; }
};
class SocketBall : public Ball {
public:
void Play() override { std::cout << "play socketball \n"; }
};
class SimpleFactory {
public:
static Ball* CreateBall(BallEnum type);
};
Ball* SimpleFactory::CreateBall(BallEnum type) {
switch (type) {
case BallEnum::BasketBall:
return new BasketBall();
case BallEnum::SocketBall:
return new SocketBall();
}
return nullptr;
}
int main() {
Ball* basket = SimpleFactory::CreateBall(BallEnum::BasketBall);
basket->Play();
Ball* socket = SimpleFactory::CreateBall(BallEnum::SocketBall);
socket->Play();
return 0;
}工厂方法模式
工厂类不再负责所有产品的构建，每一个具体产品都有一个对应的工厂，这样在新加产品时就不会改动已有工厂类的创建逻辑。这些工厂也会抽象出一个抽象工厂。当不知道以后会有多少具体产品时可以考虑使用工厂模式，因为不会降低现有系统的稳定性。
#include <iostream>
enum class BallEnum { BasketBall = 1, SocketBall = 2 };
class Ball {
public:
Ball() {}
virtual ~Ball() {}
virtual void Play() {}
};
class BasketBall : public Ball {
public:
void Play() override { std::cout << "play basketball \n"; }
};
class SocketBall : public Ball {
public:
void Play() override { std::cout << "play socketball \n"; }
};
class FactoryBase {
public:
virtual ~FactoryBase() {}
virtual Ball* CreateBall() = 0;
};
class BasketBallFactory : public FactoryBase {
public:
Ball* CreateBall() override { return new BasketBall(); }
};
class SocketBallFactory : public FactoryBase {
public:
Ball* CreateBall() override { return new SocketBall(); }
};
int main() {
FactoryBase* factory;
BallEnum ball_type = BallEnum::SocketBall;
switch (ball_type) {
case BallEnum::BasketBall:
factory = new BasketBallFactory();
break;
case BallEnum::SocketBall:
factory = new SocketBallFactory();
break;
}
Ball* ball = factory->CreateBall();
ball->Play();
return 0;
}抽象工厂模式
在工厂方法中，每一个抽象产品都会有一个抽象工厂，这样新增一个产品时都会新增两个类，一个是具体产品类，一个是具体工厂类。
#include <iostream>
enum class BallEnum { BasketBall = 1, SocketBall = 2 };
class Ball {
public:
Ball() {}
virtual ~Ball() {}
virtual void Play() {}
};
class BasketBall : public Ball {
public:
void Play() override { std::cout << "play basketball \n"; }
};
class SocketBall : public Ball {
public:
void Play() override { std::cout << "play socketball \n"; }
};
class Player {
public:
Player() {}
virtual ~Player() {}
virtual void Name() {}
};
class BasketBallPlayer : public Player {
public:
void Name() override { std::cout << "BasketBall player \n"; }
};
class SocketBallPlayer : public Player {
public:
void Name() override { std::cout << "SocketBall player \n"; }
};
class FactoryBase {
public:
virtual ~FactoryBase() {}
virtual Ball* CreateBall() = 0;
virtual Player* CreatePlayer() = 0;
};
class BasketBallFactory : public FactoryBase {
public:
Ball* CreateBall() override { return new BasketBall(); }
Player* CreatePlayer() override { return new BasketBallPlayer(); }
};
class SocketBallFactory : public FactoryBase {
public:
Ball* CreateBall() override { return new SocketBall(); }
Player* CreatePlayer() override { return new SocketBallPlayer(); }
};
int main() {
FactoryBase* factory;
BallEnum ball_type = BallEnum::SocketBall;
switch (ball_type) {
case BallEnum::BasketBall:
factory = new BasketBallFactory();
break;
case BallEnum::SocketBall:
factory = new SocketBallFactory();
break;
}
Ball* ball = factory->CreateBall();
Player* player = factory->CreatePlayer();
ball->Play();
player->Name();
return 0;
}
最新评论