第一章 代码无错就是优？——简单工厂模式

1、初学者毛病

(1)名称问题
(2)switch case 与一连串if的不同

2、结构化与面向对象程序

结构化程序的缺点：不容易维护、不容易扩展、更不容易复用。
面向对象程序设计：利用，继承、封装、多态使代码,

• 可维护，即更改方便
• 可复用，即一段代码重复使用
• 可扩展，即增加需求是修改方便
• 灵活性好，即代码间的耦合度低。

3、使用简单工厂模式、面向对象思想：实现计算器

(1)算数运算基类

public class Operation
{
	private double	numberA	= 0;
	private double	numberB	= 0;

	public double getResult() throws Exception
	{
		double result = 0;
		return result;
	}

	public double getNumberA()
	{
		return numberA;
	}

	public void setNumberA(double numberA)
	{
		this.numberA = numberA;
	}

	public double getNumberB()
	{
		return numberB;
	}

	public void setNumberB(double numberB)
	{
		this.numberB = numberB;
	}
}

(2)加减乘除法 类

public class OperationAdd extends Operation
{
	public double getResult()
	{
		double result = 0;
		result = getNumberA() + getNumberB();
		return result;
	}
}

public class OperationSub extends Operation
{
	public double getResult()
	{
		double result = 0;
		result = getNumberA() - getNumberB();
		return result;
	}
}

public class OperationMul extends Operation
{
	public double getResult()
	{
		double result = 0;
		result = getNumberA() * getNumberB();
		return result;
	}
}

public class OperationDiv extends Operation
{
	public double getResult() throws Exception
	{
		double result = 0;
		if (getNumberB() == 0)
		{
			throw new Exception("除数不能为0");
		}
		result = getNumberA() / getNumberB();
		return result;
	}
}

(3)生产加减乘除算术运算类对象的工厂类

public class OperationFactory
{
	public static Operation createOperation(String operate)
	{
		Operation oper = null;

		if ("+".equals(operate))
			oper = new OperationAdd();
		else if ("-".equals(operate))
			oper = new OperationSub();
		else if ("*".equals(operate))
			oper = new OperationMul();
		else if ("/".equals(operate))
			oper = new OperationDiv();

		return oper;
	}
}

(4)客户端代码

public class Main
{
	public static void main(String[] args)
	{
		InputStreamReader stdin = null;
		BufferedReader buffer = null;

		stdin = new InputStreamReader(System.in);
		buffer = new BufferedReader(stdin);

		try
		{
			System.out.print("请输入数字A:");
			double numberA = Double.parseDouble(buffer.readLine());
			System.out.print("请选择运算符(+、-、*、/):");
			String operator = buffer.readLine();
			System.out.print("请输入数字B:");
			double numberB = Double.parseDouble(buffer.readLine());

			Operation oper = OperationFactory.createOperation(operator);//根据operator生产运算对象
			oper.setNumberA(numberA);
			oper.setNumberB(numberB);
			System.out.println("结果是:" + oper.getResult());
		}
		catch (NumberFormatException e)
		{
			e.printStackTrace();
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
	}
}

4、本实现的类图

5、代码的总结

首先算数运算基类的设计：
(1)每种算数运算都需要获取两个操作数，因此基类中中有两个成员变量，用于存储两个操作数，并且基类有两个方法，用于设置操作数。并且需要两个成员方法，来访问这两个操作数。每种运算都有这个性质，因此可以写成是non-virtual的。这里强调的是共同性质。
(2)每种算数运算都可以获取到一个结果，但是不同的运算获取的结果不同。因此，算数基类应该有一个获取结果的成员函数，但是每种运算符得到的结果不同，因此这里强调的是特性。因此，该方法写成是pure virtual 的。

其次，四种运算符的设计：
(1)四种运算符都是一种算数运算，因此构成is-a关系，因此采用public继承。
(2)不同的运算对象的获取结果的方法不同，因此每一个运算符都要实现自己的获取结果的成员函数，此成员函数不需要获取参数，但是要返回一个值。因为它操作的就是两个成员变量。

最后，算数运算符获取的工厂类的设计
需要写一个成员方法：根据外界提供的符号信息，产生不同的运算符对象。

使用上述代码：首先根据外界提供的运算符信息和操作数信息，构造出一个运算符对象，并设置其两个成员变量。