标签：
import java.util.Scanner;
public class ProgressCalculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // 用于获取输入字符
System.out.print("请输入操作数: a = ");
int a = Integer.parseInt(scanner.nextLine()); // 输入操作数a
System.out.print("请输入操作数: b = ");
int b = Integer.parseInt(scanner.nextLine()); // 输入操作数b
System.out.print("请输入计算符号（'+', '-', '*', '/'）: ");
String oprator = scanner.nextLine(); // 输入运算符
// 判断属于运算符并计算结果
System.out.print("计算结果：");
switch (oprator) {
case "+":
System.out.println("a + b = " + (a + b)); break;
case "-":
System.out.println("a - b = " + (a - b)); break;
case "*":
System.out.println("a * b = " + (a * b)); break;
case "/":
if (b == 0) {
System.out.println("除数不能为0！");
break;
}// if
System.out.println("a / b = " + (a / b)); break;
default:
System.out.println("运算符输入错误！"); break;
}// switch_oprator
scanner.close();
}// main
}/*ProgressCalculator*//**
* 将加减乘除运算抽象成一个运算类，具有两个操作数和一个返回运算结果的方法，所有的运算子类均
* 继承自该类，从而可以利用多态性实现同一个父类引用变量实现不同子类操作的目的。
*/
abstract class Calculate {
public int num_a;
public int num_b;
abstract public int getResult();
}/*calculate*/
从能能上讲，四种运算应该是彼此独立的，根据单一职能原则，我们将这四种运算分别封装为四个不能的类，它们都继承自基本运算类并重写getResult()方法以实现自身的特有功能。// 加法运算子类
class CalculateAdd extends Calculate {
@Override
public int getResult() {
return (num_a + num_b);
}// getResult
}/*CalculateAdd*/
// 减法运算子类
class CalculateMinus extends Calculate {
@Override
public int getResult() {
return (num_a - num_b);
}// getResult
}/*CalculateMinus*/
// 乘法运算子类
class CalculateMutiple extends Calculate {
@Override
public int getResult(){
return num_a * num_b;
}// getResult
}/*CalculateMutiple*/
// 除法运算子类
class CalculateDivision extends Calculate {
@Override
public int getResult() {
if (num_b == 0)
try {
throw new Exception("除数不能为0！");
} catch (Exception e) {
e.printStackTrace();
}// try
return num_a / num_b;
}// getResult
}/*CalculateDivision*/ 为了管理各个子类对象的创建过程，我们定义了一个工厂类，其中有一个根据输入参数产生不同对象的的方法，并将创建的对象返回给一个父类（基本运算类）类型的引用。/**
* 工厂类，所有子类对象均由该类定义并返回，像一个专门生产对象的工厂，因而被称为工厂类，如果
* 要对系统进行模块的增删，仅需要修改该类即可，其他模块不受影响。
*/
class CalculateFactory {
public static Calculate createCalculate(String opt) throws Exception {
switch(opt) {
case "+":
return new CalculateAdd();
case "-":
return new CalculateMinus();
case "*":
return new CalculateMutiple();
case "/":
return new CalculateDivision();
default:
throw new Exception("运算符输入有误！");
}// switch
}// createCalculate
}/*ObjectFactory*/ 在客户端中，用户不需要了解各种运算的具体实现过程，子需要通过一个工厂类创建各个具体运算类的实例，并利用多态特性通过一个基本运算类的引用变量调用各具体运算类的功能，从而将用户与功能的具体实现隔离开来，降低了耦合性。/**
* 面向对象思想实现的计算器代码
*/
public class SimpleFactoryDemo {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
Calculate calculator = null;
System.out.print("请输入计算符号（'+', '-', '*', '/'）: ");
calculator = CalculateFactory.createCalculate(sc.nextLine()); // 根据输入的计算类型生产相应的子类
System.out.print("请输入操作数: a = ");
calculator.num_a = Integer.parseInt(sc.nextLine());
System.out.print("请输入操作数： b = ");
calculator.num_b = Integer.parseInt(sc.nextLine());
System.out.println("结果为：" + calculator.getResult());
sc.close();
}// main
}// SimpleFactoryDemo
// 工厂接口及各个运算子类的实体工厂类
interface InstanceFactory {
public Calculate creatInstance();
}/*InstanceFactory*/
// 加法工厂
class AddFactory implements InstanceFactory {
@Override
public Calculate creatInstance() {
return new CalculateAdd();
}// creatInstance
}/*AddFactory*/
// 减法工厂
class MinusFactory implements InstanceFactory {
@Override
public Calculate creatInstance() {
return new CalculateMinus();
}// creatInstance
}/*MinusFactory*/
// 乘法工厂
class MultipleFactory implements InstanceFactory {
@Override
public Calculate creatInstance() {
return new CalculateMutiple();
}// creatInstance
}/*MultipleFactory*/
// 除法工厂
class DivisionFactory implements InstanceFactory {
@Override
public Calculate creatInstance() {
return new CalculateDivision();
}// creatInstance
}/*DivisionFactory*/ 在客户端代码中，我们要先创建所需类的相应工厂实例，利用工厂实例创建所需类的实例。import java.util.Scanner;
public class FactoryMethodDemo {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // 用于获取输入字符
Calculate calculator = null;
OperationFactory factory = null;
System.out.print("请输入计算符号（'+', '-', '*', '/'）: ");
String oprator = scanner.nextLine(); // 输入运算符
// 判断属于运算符并创建相应类的工厂
switch (oprator) {
case "+":
factory = new AddFactory(); break;
case "-":
factory = new MinusFactory(); break;
case "*":
factory = new MultipleFactory(); break;
case "/":
if (b == 0) {
System.out.println("除数不能为0！");
break;
}// if
factory = new DivisionFactory(); break;
default:
System.out.println("运算符输入错误！");
break;
}// switch_oprator
calculator = factory.creatInstance();
System.out.print("请输入操作数: a = ");
calculator.num_a = Integer.parseInt(scanner.nextLine()); // 输入操作数a
System.out.print("请输入操作数: b = ");
calculator.num_b = Integer.parseInt(scanner.nextLine()); // 输入操作数b
System.out.println("结果为" + calculator.getResult());
scanner.close();
}// main
}/*FactoryMethodDemo*/
Java设计模式（一） 设计模式初探——简单工厂和工厂方法模式
标签：
原文地址：http://blog.csdn.net/u013916933/article/details/51393003
