用简单工厂模式实现--简单计算器

uml

有uml图可以看出Client依赖OprationFactory类，而OprationFactory类调用的是Opration接口，

当我们想给计算器增加功能时，修改客户端，增加相应的子类和在OprationFactory类的switch语句中增加相应的case语句即可，

不会影响其他的子类。

使用设计模式主要是提高代码的复用率，通过解耦合，使OprationFactory和Opration类能以后复用。

客户端界面：

package simpleFactory.operation002;

import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

/**
 * 
 * @author haiyusimon 通过继承和多态来实现各种运算的松耦合， 实现通过简单工厂来产生实例
 * 
 */
public class Client extends Frame {

	private static final long serialVersionUID = -4397773431585170565L;
	TextField var_a = new TextField(10);
	TextField var_b = new TextField(10);
	TextField var_r = new TextField(20);
	Button jia = new Button("加");
	Button jian = new Button("减");
	Button cheng = new Button("乘");
	Button chu = new Button("除");

	public static void main(String args[]) {
		new Client().launchFrame("计算器");
	}

	/**
	 * @param s
	 */
	public void launchFrame(String s) {
		setTitle(s);
		setBounds(10, 10, 200, 300);
		setLayout(new FlowLayout(FlowLayout.LEFT, 10, 10));
		add(new Label("第一个数："));
		add(var_a);
		add(new Label("第二个数："));
		add(var_b);
		add(new Label("运算?"));
		add(jia);
		add(jian);
		add(cheng);
		add(chu);
		add(new Label("结果："));
		add(var_r);
		pack();
		setVisible(true);
		addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		jia.addActionListener(new ClientMonitor('+'));
		jian.addActionListener(new ClientMonitor('-'));
		cheng.addActionListener(new ClientMonitor('*'));
		chu.addActionListener(new ClientMonitor('/'));
	}

	private class ClientMonitor implements ActionListener {

		char coperator = '+'; // 用来判断是哪个按钮

		public ClientMonitor(char operator) {
			this.coperator = operator;
		}

		public void actionPerformed(ActionEvent e) {
			double var_aa = Double.parseDouble(var_a.getText());
			double var_ab = Double.parseDouble(var_b.getText());
			double r = OperationFactory.createOperation(coperator, var_aa, var_ab);
			var_r.setText("" + r);
		}
	}
}

工厂类：

package simpleFactory.operation002;
/**
 * 
 * @author haiyusimon
 *将由工厂类产生相应的运算类实例
 */
public class OperationFactory {
	public static double createOperation(char operator,double var_aa,double var_ab) {
		double r = 0.0;
		Operation operation = new OprationAdd(); //使用接口，把类隐藏在接口下
		switch (operator) {
		case '+':
			operation = new OprationAdd();
            break;  //最后必需有break;语句，不然将逐一运行各种情况
		case '-':
			operation = new OprationSub();
			break;
		case '*':
			operation = new OprationMul();
			break;
		case '/':
			operation = new OprationDiv();
			break;
		}
		r = operation.getResult(var_aa, var_ab);
		return r;
	}
}

运算接口：

package simpleFactory.operation002;

public interface Operation {
    public double getResult(double a,double b);
}

加法运算（继承运算接口）：

package simpleFactory.operation002;

public class OprationAdd implements Operation {

	@Override
	public double getResult(double a, double b) {
		return a + b;
	}

}

减法运算（继承运算接口）：

package simpleFactory.operation002;

public class OprationSub implements Operation {

	@Override
	public double getResult(double a, double b) {
		return a - b;
	}

}

乘法运算（继承运算接口）：

package simpleFactory.operation002;

public class OprationMul implements Operation {

	@Override
	public double getResult(double a, double b) {
		return a * b;
	}

}

除法运算（继承运算接口）：

package simpleFactory.operation002;

public class OprationDiv implements Operation {

	@Override
	public double getResult(double a, double b) {
		return a / b;
	}

}