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

无意间翻出了之前买的一本书《大话设计模式》读了一遍,受益匪浅,决定将其中的代码用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);
}
}

  

设计模式——简单工厂模式(SimpleFactory Pattern)的更多相关文章

  1. Golang设计模式—简单工厂模式(Simple Factory Pattern)

    Golang设计模式--简单工厂模式 背景 假设我们在做一款小型翻译软件,软件可以将德语.英语.日语都翻译成目标中文,并显示在前端. 思路 我们会有三个具体的语言翻译结构体,或许以后还有更多,但现在分 ...

  2. 简单工厂模式 SimpleFactory

     简单工厂模式 SimpleFactory 1.1什么是简单工厂设计模式 简单工厂模式是属于创建型模式,又叫做静态工厂方法(Static Factory Method)模式,但不属于23种GOF设计模 ...

  3. 3. 星际争霸之php设计模式--简单工厂模式

    题记==============================================================================本php设计模式专辑来源于博客(jymo ...

  4. python 设计模式之工厂模式 Factory Pattern (简单工厂模式,工厂方法模式,抽象工厂模式)

    十一回了趟老家,十一前工作一大堆忙成了狗,十一回来后又积累了一大堆又 忙成了狗,今天刚好抽了一点空开始写工厂方法模式 我看了<Head First 设计模式>P109--P133 这25页 ...

  5. IOS设计模式浅析之简单工厂模式(SimpleFactory)

    概述 首先说明一下,简单工厂模式不属于23种GOF设计模式之一.它也称作静态工厂方法模式,是工厂方法模式的特殊实现.这里对简单工厂模式进行介绍,是为本系列后面的工厂方法和抽象工厂模式做一个引子. 定义 ...

  6. Java设计模式 -- 简单工厂模式(SimpleFactory)

    一.什么是简单工厂模式 简单工厂模式属于类的创建型模式,又叫做静态工厂方法模式.通过专门定义一个类来负责创建其他类的实例,被创建的实例通常都具有共同的父类. 二.模式中包含的角色及其职责 1.工厂(C ...

  7. 设计模式-简单工厂模式(SimpleFactory)

    简单工厂模式又叫静态工厂模式,,通过定义一个类(FruitFactory)来负责创建其他类的实例,被创建的实例通常都具有相同的父类(Fruit). 角色和职责: 1.工厂角色(Factory)-Fru ...

  8. C++设计模式——简单工厂模式

    简单工厂模式(Simple Factory Pattern) 介绍:简单工厂模式不能说是一个设计模式,说它是一种编程习惯可能更恰当些.因为它至少不是Gof23种设计模式之一.但它在实际的编程中经常被用 ...

  9. 深入浅出设计模式——简单工厂模式(Simple Factory)

    介绍简单工厂模式不能说是一个设计模式,说它是一种编程习惯可能更恰当些.因为它至少不是Gof23种设计模式之一.但它在实际的编程中经常被用到,而且思想也非常简单,可以说是工厂方法模式的一个引导,所以我想 ...

随机推荐

  1. oracle基础知识(六)----spfile与pfile

    一, 认识参数文件      Oracle中的参数文件是一个包含一系列参数以及参数对应值的操作系统文件.它们是在数据库实例启动时候加载的,决定了数据库的物理 结构.内存.数据库的限制及系统大量的默认值 ...

  2. org.springframework.dao.DataIntegrityViolationException: could not execute statement; SQL [n/a]; constraint [null]; nested exception is org.hibernate.

    今天报了这个异常,这是页面报的 org.springframework.dao.DataIntegrityViolationException: could not execute statement ...

  3. lua实现List及Dictionary

    转载:http://www.maosongliang.com/archives/122 参考 http://blog.csdn.net/jason_520/article/details/541736 ...

  4. github不支持tlsv1.1后, 出现SSL connect error

    过完年回来, github不安分了, 发了博文说不支持TLSv1/TLSv1.1: Weak cryptographic standards removed, 没看到这篇博文之前, 还以为是代理问题, ...

  5. NDK编译不同架构的参数

    随着Android的蓬勃发展, CPU的架构也越来越多. 早期只支持ARMv5, 截至目前, 支持的架构已达三类七种: ARM(ARMv5,ARMv7 (从2010年起),ARMv8), x86(x8 ...

  6. 结合manage.py,在flask项目中使用websocket模块--- flask-socketio

    前言:       - 为什么我要使用 flask-socketio模块,而不是flask-sockets?       - 因为flask-socketio与前端流行的websocket库socke ...

  7. 0、安装Ionic2

    1.安装ionic2 $ npm install -g ionic@beta 2.创建项目 $ ionic start 项目名称 --v2 //  默认tabs的模板 $ ionic start 项目 ...

  8. Hashtable语法简介

    Hashtable简述 Hashtable是System.Collections命名空间提供的一个容器 Hashtable中keyvalue键值对均为object类型,所以Hashtable可以支持任 ...

  9. python的元组及其书写规矩

    1.元组 (1)元组看起来犹如列表,但使用圆括号而不是方括号来标识.定义元组后,就可以使用索引来访问其元素,就像访问列表元素一样. (2)元组的元素不可修改,但是可以赋值. 2.规矩 (1)缩进:建议 ...

  10. UDP client,UDP server, TCP server, TCP client

    UDP server import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocke ...