1. 模式的定义

问题的描述：

//这种方式与面向接口编程的封装行为相悖
Api api = new Impl();

现在的Client，它知道要使用Api接口，但是不知由谁实现，也不知道如何实现，该怎么办？

简单工厂的定义：

提供一个创建对象实例的功能，而无需关心其具体实现。

2. UML图

Api：定义客户端所需要的功能接口
ImplA，ImplB：具体实现Api的实例类
Factorty：工厂类，选择合适的实现类来创建对象
Client：客户端，通过Factory来获取Api接口对象

代码：

/**
 * 接口的定义，该接口可以通过简单工厂来创建
 */
public interface Api {
    /**
     * 示意，具体的功能方法的定义
     * @param s 示意，需要的参数
     */
    public void operation(String s);
}

/**
 * 接口的具体实现对象A 
 */
public class ImplA implements Api{
    public void operation(String s) {
        //实现功能的代码，示意一下
        System.out.println("ImplA s=="+s);
    }
}

/**
 * 接口的具体实现对象B 
 */
public class ImplB implements Api{
    public void operation(String s) {
        //实现功能的代码，示意一下
        System.out.println("ImplB s=="+s);
    }
}

/**
 * 工厂类，用来创造Api对象
 */
public class Factory {
    /**
     * 具体的创造Api对象的方法
     * @param condition 示意，从外部传入的选择条件
     * @return 创造好的Api对象
     */
    public static Api createApi(int condition){
        //应该根据某些条件去选择究竟创建哪一个具体的实现对象
        //这些条件可以从外部传入，也可以从其它途径获取
        //如果只有一个实现，可以省略条件，因为没有选择的必要

        //示意使用条件
        Api api = null;
        if(condition == 1){
            api = new ImplA();
        }else if(condition == 2){
            api = new ImplB();
        }
        return api;
    }
}

/**
 * 客户端，使用Api接口
 */
public class Client {
    public static void main(String[] args) {
        //通过简单工厂来获取接口对象
        Api api = Factory.createApi(1);
        api.operation("正在使用简单工厂");
    }
}

3. 研磨设计模式

接口的思想：封装隔离。对被隔离体的行为的封装，隔离是指外部调用和内部实现，外部调用只能通过接口进行调用，外部调用不知道内部具体实现的，即外部调用和内部实现是被接口隔离开的。

接口是用来封装隔离具体实现的

简单工厂命名的建议：
类名称建议：”模块名称+Factory”
方法名称建议：”get+接口名称”或者”create+接口名称”

简单工厂的实质：选择实现

新增一个实现类就要修改Factory，解决方法：使用配置文件

/**
 * 工厂类，用来创造Api对象
 */
public class Factory {
    /**
     * 具体的创造Api的方法，根据配置文件的参数来创建接口
     * @return 创造好的Api对象
     */
    public static Api createApi(){
        //直接读取配置文件来获取需要创建实例的类

        //至于如何读取Properties还有如何反射这里就不解释了
        Properties p = new Properties(); 
        InputStream in = null;
        try {
            in = Factory.class.getResourceAsStream("FactoryTest.properties");
            p.load(in);
        } catch (IOException e) {
            System.out.println("装载工厂配置文件出错了，具体的堆栈信息如下：");
            e.printStackTrace();
        }finally{
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //用反射去创建，那些例外处理等完善的工作这里就不做了
        Api api = null;
        try {
            api = (Api)Class.forName(p.getProperty("ImplClass")).newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return api;
    }
}