最近做项目总是遇到这样或者那样的问题，代码不够简洁，代码可扩展性不够好，耦合度又太高了，导致经常有种想去重构又无从下手的感觉。
无意间翻出了之前买的一本书《大话设计模式》读了一遍，受益匪浅，决定将其中的代码用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);
}
}