现在我的感觉是，之所以花大力气，学习设计模式，主要是为了程序以后的扩展，而我也越来越意识到，程序扩展的重要性。而java之所以容易扩展主要得力与面向对象里的继承和多态。
今天写了个工厂模式实验代码，在此记下来，留着以后学习回忆。
工厂方法模式与简单工厂模式最大的区别在于： 简单工厂最大的优点在于，工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态示例化相关的类，对于客户端来说，去除了与具体产品的依赖。（出自大话设计模式）
它的uml建模图据说是这样的
第一次画建模图^_^
具体代码就在这里
package com.dic.simple.operation;
/**
* 运算类顶级接口
*
*
* @author roger.han（[email protected]）
*
*/
public interface Operation
{
/**
*
* @param a
* @param b
*/
public void operate(int a,int b);
}
package com.dic.simple.operation;
/**
* 加法操作的具体实现
*
* @author roger.han（[email protected]）
*
*/
public class AddOperation implements Operation{
/*
* (non-Javadoc)
* @see com.dic.simple.operation.Operation#operate(int, int)
*/
@Override
public void operate(int a,int b) {
// TODO Auto-generated method stub
System.out.println(a+b);
}
}package com.dic.simple.operation;
/**
* 乘法运算的具体实现
*
* @author roger.han（[email protected]）
*
*/
public class MultiplyOperation implements Operation
{
/*
* (non-Javadoc)
* @see com.dic.simple.operation.Operation#operate(int, int)
*/
@Override
public void operate(int a, int b) {
// TODO Auto-generated method stub
System.out.println(a*b);
}
}package com.dic.simple.factory;
import com.dic.simple.operation.AddOperation;
import com.dic.simple.operation.MultiplyOperation;
import com.dic.simple.operation.Operation;
/**
* 简单工厂类 用于生成具体的操作对象 <span style="color:#ff0000;">具体生成对象的逻辑在简单工厂里实现</span>
*
* @author roger.han（[email protected]）
*
*/
public class SimpleFactory
{
/**
*
* @param i 此处偷懒，0-->add 1-->multiply
* @return
*/
public static Operation getOperation(int i)
{
Operation oper;
switch(i)
{
case 0:oper=new AddOperation();break;
case 1:oper=new MultiplyOperation();break;
default: return null;
}
return oper;
}
}
package com.dic.client;
import com.dic.simple.factory.SimpleFactory;
import com.dic.simple.operation.Operation;
/**
* 简单工厂的调用客户端
* @author roger.han（[email protected]）
*
*/
public class SimpleClient
{
public static void main(String[] args)
{
Operation o=SimpleFactory.getOperation(1);
o.operate(1, 2);
}
}
抽象工厂的uml图据说是这样
代码是这样
package com.dic.factory;
import com.dic.simple.operation.Operation;
/**
*
* 抽象工厂顶级接口类
*
*
*
* @author roger.han（[email protected]）
*
*/
public interface IFactory
{
public Operation getOperation();
}
package com.dic.factory;
import com.dic.simple.operation.AddOperation;
import com.dic.simple.operation.Operation;
/**
*
* 加法工厂 生产加法类
*
* @author roger.han（[email protected]）
*
*
*
*/
public class AddOperationFatory implements IFactory{
@Override
public Operation getOperation() {
// TODO Auto-generated method stub
return new AddOperation();
}
}
package com.dic.factory;
import com.dic.simple.operation.MultiplyOperation;
import com.dic.simple.operation.Operation;
/**
*
* 乘法工厂 生产乘法法类
*
* @author roger.han（[email protected]）
*
*
*
*/
public class MultiplyOperationFactory implements IFactory {
@Override
public Operation getOperation() {
// TODO Auto-generated method stub
return new MultiplyOperation();
}
}
package com.dic.client;
import com.dic.factory.IFactory;
import com.dic.factory.MultiplyOperationFactory;
import com.dic.simple.operation.Operation;
/**
* 抽象工厂调用客户端
*
* @author work
*
*/
public class Client
{
public static void main(String[] args)
{
IFactory i=new MultiplyOperationFactory();//<span style="color:#ff0000;">而抽象工厂的逻辑在这里</span>
Operation o=i.getOperation();
o.operate(1,2);
}
}
好了 终于把简单工厂和抽象工厂写完了 这时候如果想加个减法的话 简单工厂需要怎么做 而抽象工厂又需要怎么做
简单工厂要修改SimpleFactory的代码 还有客户端的代码 来获得减法类 ，抽象工厂又需要怎么做，它需要写一个新的工程 MinusFactory 来集成IIFactory实现产生运算累得方法
再客户端程序需要改下，具体的工厂。那个更好呢？老鸟是这么说的 简单工厂违背了开放封闭原则（软件实体《类，模块，函数等》应该可以扩展但不可已修改），但保持了封装对象创建过程的优点，这两种途径都是集中封装了对象的创建过程，使得更换对象时，不许要做大的改动就可以实现，降低了客户端程序域产品对象的耦合，抽象工厂模式是简单工厂模式的进一步抽象和推广（摘自大话设计模式）
老鸟是菜鸟进步的阶梯 再次感谢那些乐于分享经验的老鸟