设计模式——简单工厂模式(SimpleFactory Pattern)

　　最近做项目总是遇到这样或者那样的问题，代码不够简洁，代码可扩展性不够好，耦合度又太高了，导致经常有种想去重构又无从下手的感觉。

无意间翻出了之前买的一本书《大话设计模式》读了一遍，受益匪浅，决定将其中的代码用java来实现一遍，个中精髓自行体会，

此处只做代码的具体实现。^-^

　　UML图：

　　


　　模型：

　　产品基类：Product　　

package com.cnblog.clarck;

/**
* 产品类
*
* @author clarck
*
*/
public class Product {
/**
* 创建产品
*
* @return
*/
public String createRealProduct() {
String product = "";
return product;
}
}

　　产品A的实例:ProductA

　　

package com.cnblog.clarck;

/**
* 产品A
*
* @author clarck
*
*/
public class ProductA extends Product {

@Override
public String createRealProduct() {
String productA = "产品A";
return productA;
}

}

　　产品B的实例:ProductB

package com.cnblog.clarck;

/**
* 产品B
*
* @author clarck
*
*/
public class ProductB extends Product {

@Override
public String createRealProduct() {
String productB = "产品B";
return productB;
}

}

　　简单工厂类:ProductFactory

package com.cnblog.clarck;

/**
* 产品工厂
*
* @author clarck
*
*/
public class ProductFactory {
public static Product createProduct(ProductType type) {
Product product = null;
switch (type) {
case PRODUCTA:
product = new ProductA();
break;

case PRODUCTB:
product = new ProductB();
break;

default:
break;
}
return product;
}
}

　　产品类型:ProductType　

package com.cnblog.clarck;

/**
* 产品A，产品B的类型
*
* @author clarck
*
*/
public enum ProductType {
PRODUCTA, PRODUCTB
}

　　测试类：Test

package com.cnblog.clarck;

/**
* 测试用例
*
* @author clarck
*
*/
public class Test {
public static void main(String[] args) {
Product product = ProductFactory.createProduct(ProductType.PRODUCTA);
String productA = product.createRealProduct();
System.out.println(productA);

product = ProductFactory.createProduct(ProductType.PRODUCTA);
String productB = product.createRealProduct();
System.out.println(productB);
}
}

　　实例运用：

　　---------------------------------------------------------------------------------------

　　数据运算基类：Operation

package com.cnblog.clarck;

/**
* 数据运算基类
*
* @author clarck
*
*/
public class Operation {
private double mNmberA = 0;
private double mNumberB = 0;

public double getNumberA() {
return mNmberA;
}

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

public double getNumberB() {
return mNumberB;
}

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

/**
* 获取运算结果
* @return
*/
public double getResult() {
double result = 0;
return result;
}

}

　加法类：OperationAdd

package com.cnblog.clarck;

/**
* 加法类
*
* @author clarck
*
*/
public class OperationAdd extends Operation {

@Override
public double getResult() {
double result = 0;
result = getNumberA() + getNumberB();
return result;
}

}

减法运算类：OperationSub

package com.cnblog.clarck;

/**
* 减法类
*
* @author clarck
*
*/
public class OperationSub extends Operation {

@Override
public double getResult() {
double result = getNumberA() - getNumberB();
return result;
}

}

乘法运算类：OperationMul

package com.cnblog.clarck;

/**
* 乘法
*
* @author clarck
*
*/
public class OperationMul extends Operation {

@Override
public double getResult() {
double result = getNumberA() * getNumberB();
return result;
}

}

除法类：OperationDiv

package com.cnblog.clarck;

/**
* 除法类
*
* @author clarck
*
*/
public class OperationDiv extends Operation {

@Override
public double getResult() {
if (getNumberB() == 0) {
throwException();
}

double result = getNumberA() / getNumberB();
return result;
}

private void throwException() {
try {
throw new Exception("除数不能为0.");
} catch (Exception e) {
e.printStackTrace();
}
}
}

简单工厂类：OperationFactory

package com.cnblog.clarck;

/**
* 工厂类
*
* @author clarck
*
*/
public class OperationFactory {
/**
* 创建运算类的工厂
*
* @param operate
*            运算类对象
* @return
*             创建成功-运算类对象,返回空
*/
public static Operation createOperation(OperationSymbol operate) {
Operation oper = null;
switch (operate) {
case ADDITION:
oper = new OperationAdd();
break;

case SUBTRACTION:
oper = new OperationSub();
break;

case MULTIPLICATION:
oper = new OperationMul();
break;

case DIVISION:
oper = new OperationDiv();
break;

default:
break;
}
return oper;
}
}

运算符号类：OperationSymbol

package com.cnblog.clarck;

/**
* 加法， 减法， 乘法， 除法
*
* @author clarck
*
*/
public enum OperationSymbol {
ADDITION, SUBTRACTION, MULTIPLICATION, DIVISION
}

测试类：Test

package com.cnblog.clarck;

/**
* 测试类
*
* @author clarck
*
*/
public class Test {
public static void main(String[] args) {
Operation oper = null;
oper = OperationFactory.createOperation(OperationSymbol.ADDITION);
oper.setNmberA(1.0);
oper.setNumberB(2.0);
double addResult = oper.getResult();
System.out.println("addResult =" + addResult);

oper = OperationFactory.createOperation(OperationSymbol.SUBTRACTION);
oper.setNmberA(1.0);
oper.setNumberB(2.0);
double subResult = oper.getResult();
System.out.println("subResult =" + subResult);

oper = OperationFactory.createOperation(OperationSymbol.MULTIPLICATION);
oper.setNmberA(1.0);
oper.setNumberB(2.0);
double mulResult = oper.getResult();
System.out.println("mulResult =" + mulResult);

oper = OperationFactory.createOperation(OperationSymbol.DIVISION);
oper.setNmberA(1.0);
oper.setNumberB(2.0);
double divResult = oper.getResult();
System.out.println("divResult =" + divResult);
}
}