【设计模式2】简单工厂类

简单工厂模式

创建工厂类，通过传入参数，让工厂知道应该创建什么对象。
优点：
1、客户端与具体实现类解耦。
2、不需要考虑某些类创建过程比较复杂情况。
缺点：
1、增加新功能需要修改源代码，不符合开闭原则。
2、工厂类职责过重，出现问题影响整个模块。

注意简单工厂类的创建对象的函数为静态成员函数，与类本身绑定，即不需要实例化工厂类生成工厂类对象就可以创建底下对应的类对象。
UML类图大概是 工厂类依赖于抽象类，实现类继承抽象类（偷懒不贴图了）

#include <iostream>
using namespace std;
/*黑马程序员--水果简单工厂类*/
class AbstractFruit {
public:
	virtual void ShowName() = 0;
};

class Apple :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "Apple" << endl;
	}
};

class Orange :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "Orange" << endl;
	}
};

class Pear :public AbstractFruit {
public:
	virtual void ShowName() {
		cout << "Pear" << endl;
	}
};

class FruitFractory {
public:
	static AbstractFruit* CreatFruit(string flag) {
		if (flag == "Apple") return new Apple;
		else if (flag == "Orange") return new Orange;
		else if (flag == "Pear") return new Pear;
		else return nullptr;
	}
};

void test01() {
	FruitFractory* factory = new FruitFractory;
	AbstractFruit* fruit = factory->CreatFruit("Apple");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreatFruit("Orange");
	fruit->ShowName();
	delete fruit;

	fruit = factory->CreatFruit("Pear");
	fruit->ShowName();
	delete fruit;

	delete factory;
}
int main() {
	test01();
	system("pause");
	return 0;
}

大话设计模式的代码还不太完善，c#的语法搞得我恶心。
c#可以私有成员声明初始化，switch的case可以是字符串，还有那个公有变量的声明还是啥我也没看懂。。。

/*大话设计模式--计算器简单工厂类*/
class AbstractOperation {
public:
	virtual double getResult() = 0;
	void set(double num1, double num2) {
		this->num1 = num1;
		this->num2 = num2;
	}
protected:
	double num1;
	double num2;
};

class OperationAdd:public AbstractOperation {
public:
	virtual double getResult() {
		return num1 + num2;
	}
};

class OperationSub :public AbstractOperation {
public:
	virtual double getResult() {
		return num1 - num2;
	}
};

class OperationMul :public AbstractOperation {
public:
	virtual double getResult() {
		return num1 * num2;
	}
};

class OperationDiv :public AbstractOperation {
public:
	virtual double getResult() {
		if (num2 == 0) {
			cout << "除数不得为0" << endl;
			return 0.0;
		}
		else return num1 / num2;
	}
};

class OperationFactory
{
public:
	static AbstractOperation* CreatOperationFactory(char operate) {
		switch (operate)
		{
		case '+':
			return new OperationAdd;
		case '-':
			return new OperationSub;
		case '*':
			return new OperationMul;
		case '/':
			return new OperationDiv;
		default:
			return nullptr;
		};
	}


};
void test02() {
	OperationFactory* factory = new OperationFactory;
	AbstractOperation* operation = factory->CreatOperationFactory('+');
	cout << "输入两数相加：" << endl;
	double num1, num2, res;
	cin >> num1 >> num2;
	operation->set(num1, num2);
	cout << operation->getResult() << endl;
	delete operation;

	operation = factory->CreatOperationFactory('-');
	cout << "输入两数相减：" << endl;
	cin >> num1 >> num2;
	operation->set(num1, num2);
	cout << operation->getResult() << endl;
	delete operation;

	operation = factory->CreatOperationFactory('*');
	cout << "输入两数相乘：" << endl;
	cin >> num1 >> num2;
	operation->set(num1, num2);
	cout << operation->getResult() << endl;
	delete operation;

	operation = factory->CreatOperationFactory('/');
	cout << "输入两数相除：" << endl;
	cin >> num1 >> num2;
	operation->set(num1, num2);
	cout << operation->getResult() << endl;
	delete operation;

	delete factory;

}
int main() {
	test02();
	system("pause");
	return 0;
}