本文通过运用设计模式比没用设计模式的优势在哪?
设计模式主要是要抓住稳定部分和易变部分,文章结尾会指出。
还指出工厂方法被设计出来,最开始想要解决的问题是什么。
#include <iostream>
using namespace std;
//老代码
class Fruit {
public:
virtual void eaten() = 0;
virtual ~Fruit() {}
};
class Apple : public Fruit {
public:
void eaten() override {
cout << "eat apple" << endl;
}
};
class Orange : public Fruit {
public:
void eaten() override {
cout << "eat orange" << endl;
}
};
class Banana: public Fruit {
public:
void eaten() override {
cout << "eat banana" << endl;
}
};
//老代码
class Man {
public:
void eat() {
Fruit *fruit = new Apple; //这里违背了"不与陌生人交流的原则"
fruit->eaten();
delete(fruit);
}
};
//需求改变,Man可以吃任意的水果。注意fruit被吃掉后,需要在eat中析构。
//新增枚举,修改Man::eat方法
//这种方法违背开闭原则,如果在添加水果种类,还要修改FruitType和Man2类。
enum FruitType {
APPLE,
ORANGE,
BANANA
};
class Man2 {
public:
void eat(FruitType type) {
Fruit *fruit = nullptr;
switch (type) {
case APPLE:
fruit = new Apple;
break;
case ORANGE:
fruit = new Orange;
break;
case BANANA:
fruit = new Banana;
break;
}
fruit->eaten();
delete(fruit);
}
};
//工厂方法
//抽象工厂
//将来在新增水果类只需要增加对应的工厂方法。
class FruitFactory {
public:
virtual Fruit* creatFruit() = 0;
virtual ~FruitFactory() {}
};
class AppleFactory : public FruitFactory {
public:
Fruit* creatFruit() override {
return new Apple;
}
};
class OrangeFactory : public FruitFactory {
public:
Fruit* creatFruit() override {
return new Orange;
}
};
class BananaFactory : public FruitFactory {
public:
Fruit* creatFruit() override {
return new Banana;
}
};
class Man3 {
public:
void eat(FruitFactory *factory) {
Fruit *fruit = factory->creatFruit();
fruit->eaten();
delete(fruit);
}
};
int main()
{
Man().eat();
Man2().eat(BANANA);
FruitFactory *factory = new OrangeFactory;
Man3().eat(factory);
delete(factory);
return 0;
}
工厂方法稳定部分:Fruit/FruitFactory
类,易变部分是:它们的子类。
策略方法让Fruit
类解耦,但是又new
的存在还是要改变Man::eat
函数,工厂方法最开始是为了解决new
带来的问题。