设计模式之简单工厂模式

简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式，但不属于23种GOF设计模式之一。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。简单工厂模式是工厂模式家族中最简单实用的模式，可以理解为是不同工厂模式的一个特殊实现。

下面就是工厂模式的核心代码：

package com.shijinnan.design;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Properties;


import com.shijinnan.classes.Operation;
import com.shijinnan.consts.Const;

public class Factory
{
private static Factory instance = new Factory();

private Map<String,Operation> map = new HashMap<String,Operation>(Const.DEFAULT);
public static Factory getInstance()
{
return instance;
}

private Factory()
{
init();
}

private void init() 
{
String filePath = "D:\\class.properties";
Properties pro = new Properties();
FileInputStream in = null;
try
{

in = new FileInputStream(filePath);
pro.load(in);
Iterator<String> it = pro.stringPropertyNames().iterator();
String key = null;
String values = null;
Class<? extends Factory> loadClass = this.getClass();
ClassLoader loader = loadClass.getClassLoader();
Class<?>c = null;
Operation oper = null;
while(it.hasNext())
{
key = it.next();
values = pro.getProperty(key);

c = loader.loadClass(values);

oper = (Operation) c.newInstance();
map.put(key, oper);

}


}
catch (FileNotFoundException e)
{

e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
catch (ClassNotFoundException e)
{

e.printStackTrace();
}
catch (InstantiationException e)
{

e.printStackTrace();
}
catch (IllegalAccessException e)
{
e.printStackTrace();
}
finally
{
if(in != null)
{
try
{
in.close();
}
catch (IOException e)
{

e.printStackTrace();
}
}
}
System.out.println(map);


}

public Operation getOperation(String oper)
{
System.out.println(map);
Operation oper1 = null;
if(map.containsKey(oper))
{
oper1 = map.get(oper);
}
return oper1;
}
}

抽象类的Operation和它的子类的的代码：

package com.shijinnan.classes;


public abstract class Operation
{


protected double number1;


public double getNumber1()
{
return number1;
}


public void setNumber1(double number1)
{
this.number1 = number1;
}


protected double nulber2;


/**
 * des:运算的方法
 * 
 * @return 结果
 */
public abstract double operate();
}

package com.shijinnan.classes;


public class AddOperation extends Operation
{



@Override
    public double operate()
    {
    return this.number1+this.nulber2;
    }

}

上面的根据配置文件class.properties：

ad=com.shijinnan.classes.AddOperation

初始化对应的类的对象，然后放到一个容器里，然后根据外界给定的信息，决定创建哪个具体的对象，然后返回给调用者。

简单工厂模式的优缺点：

优点：简单工厂模式能够根据外界给定的信息，决定究竟应该创建哪个具体类的对象。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

缺点：很明显工厂类集中了所有实例的创建逻辑，容易违反GRASPR的高内聚的责任分配原则

如有问题，欢迎各位牛人指出