• 简单工厂
• 工厂方法
• 抽象工厂

代码都来源于生活，设计模式同样是生活中某些事物的抽象。

例如工厂模式，比如一个生产衣服的工厂（ClothesFactory），不同的车间生产不同的衣服，但是一个工厂可以生产出各式各样的衣服（TShirt、Jacket、Jeans等等），我们作为客户并不需要关系那个车间生产什么样的衣服，我只是需要衣服而已。我们只需要向工厂表名自己的需求（向工厂发出请求），工厂就可以给我们相应的衣服（工厂反馈相应衣服）。

一、简单工厂

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

代码实现（以制衣厂为例）：

• 业务类统一接口

/**
 * 创建统一的制作衣服接口类
 */
public interface IMakeClothes {
    /**
     * 制作衣服统一的接口
     */
    void createCloth();
}

• 业务类具体实现

/**
 * 制作T恤的具体业务类
 */
public class TShirtClothes implements IMakeClothes {
    @Override
    public void createCloth() {
        System.out.println("制作T恤衫....");
    }
}

/**
 * 制作夹克衫的业务类
 */
public class JacketClothes implements IMakeClothes {
    @Override
    public void createCloth() {
        System.out.println("制作夹克衫....");
    }
}

/**
 * 制作牛仔衫的业务类
 */
public class JeansClothes implements IMakeClothes {
    @Override
    public void createCloth() {
        System.out.println("制作牛仔衫....");
    }
}

• 工厂类（简单工厂模式的核心）

/**
 * 制衣服工厂类（简单工厂模式的核心）
 */
public class ClothesFactory {
    public static IMakeClothes makeClothes;

    /**
     * 根据用户请求，实例化相应的产品类
     * @param clothesType 用户请求的产品类型
     * @return
     * @throws ClassNotFoundException
     */
    public static IMakeClothes getMakeClothesInstance(String clothesType) throws ClassNotFoundException {
        switch (clothesType) {
            case "TShirt":
                makeClothes = new TShirtClothes();
                break;
            case "Jacket":
                makeClothes = new JacketClothes();
                break;
            case "Jeans":
                makeClothes = new JeansClothes();
                break;
            default:
                throw new ClassNotFoundException();
        }

        return makeClothes;
    }
}

• 客户端

/**
 * 客户端测试类
 */
public class Client {
    public static void main(String[] args) {
        try {
            // 需要牛仔衫客户的请求
            IMakeClothes jeansClothes = ClothesFactory.getMakeClothesInstance("Jeans");
            jeansClothes.createCloth();

            // 需要夹克衫客户的请求
            IMakeClothes jacketClothes = ClothesFactory.getMakeClothesInstance("Jacket");
            jacketClothes.createCloth();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

• 输出结果：

制作牛仔衫....
制作夹克衫....

总结：

优点：

• 1、简单工厂模式的核心在于Factory类，包含处理逻辑，决定何时去创建产品，客户端只是需要传递对应的参数，即可以完成产品的创建。
• 2、 通过工厂类的使用，可以将客户端和服务端分离，客户端只需要传递参数，服务端实现具体细节，在一定程度上提高的系统的灵活性。

缺点：

• 1、工厂类囊括了所有产品（实例）创建逻辑，如果产品过多，将会是工厂类逻辑复杂，不易维护和扩展。

二、工厂方法

工厂方法指的是定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到了子类[DP] 。对于简单工厂，工厂方法更加抽象、职责单一，简单工厂违背了开闭原则，工厂方法正是优化了这个问题，对工厂职责的划分，采用接口各自实现，体现了开闭原则。

代码实现（依然采用简单工厂的例子）：

• 业务类接口，以及业务类具体实现与简单工厂一致。
• 工厂类统一接口

public interface IClothesFactory {
    /**
     * 根据用户请求，实例化相应的产品类
     * @return
     */
    IMakeClothes getMakeClothesInstance();
}

• 工厂类具体实现

/**
 * T恤类制衣工厂
 */
public class TShirtFactory implements IClothesFactory {
    @Override
    public IMakeClothes getMakeClothesInstance() {
        return new TShirtClothes();
    }
}

/**
 * 牛仔类制衣工厂
 */
public class JeansFactory implements IClothesFactory {
    @Override
    public IMakeClothes getMakeClothesInstance() {
        return new JeansClothes();
    }
}

/**
 *  夹克类制衣工厂
 */
public class JacketFactory implements IClothesFactory {
    @Override
    public IMakeClothes getMakeClothesInstance() {
        return new JacketClothes();
    }
}

• 客户端测试代码

public class Client {
    public static void main(String[] args) {
        // 牛仔制衣工厂
        IClothesFactory clothesFactory = new JeansFactory();
        IMakeClothes jeansClothes = clothesFactory.getMakeClothesInstance();
        jeansClothes.createCloth();

        // 夹克制衣工厂
        clothesFactory = new JacketFactory();
        IMakeClothes jacketClothes = clothesFactory.getMakeClothesInstance();
        jacketClothes.createCloth();
    }
}

• 输出结果

制作牛仔衫....
制作夹克衫....

总结：

工厂方法模式可以说是简单工厂模式的进一步抽象和拓展，在保留了简单工厂模式的封装优点的同时，让扩展变得简单，让继承变得可行，同时又增加了多态性的体现。

优点：

• 1、针对使用，客户端创建产品只需要知道其工厂名称即可，屏蔽了产品具体实现。
• 2、针对扩展，开发者需要增加一个产品类，一个产品工厂即可。（对修改封闭，对扩展开放，即：开放-封闭原则）

缺点：

• 1、如果产品过多会导致系统的类成倍增加，会使系统变得复杂。

三、抽象工厂

• 抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们的具体类[DP]。
• 以数据访问采用何种数据库为例，在实际开发过程中，如果为防止数据库的变更而产生大量的重复工作，因此我们在设计初期就应该考虑到这种局面。 在做数据访问的时候，就应该进行相对完善的封装，从而使得后期的维护工作量尽可能降到最低。 例如我们需要将某应用的Access数据切换为MySQL或者Oracle数据库，我们可以就可以采用抽象工厂来完成，定义统一的工厂接口，不同的数据库根据自己的协议创建实例。在客户端只需要根据自己采用的数据库修改自己要创建的工厂实例

代码实现

• 业务实体类

/**
 * 用户实体类
 */
public class User {
    private String userId;
    private String userName;

    public User(String userId, String userName) {
        this.userId = userId;
        this.userName = userName;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
}

/**
 * 部门实体类
 */
public class Department {
    private String deptCode;
    private String deptName;

    public Department(String deptCode, String deptName) {
        this.deptCode = deptCode;
        this.deptName = deptName;
    }

    public String getDeptCode() {
        return deptCode;
    }

    public void setDeptCode(String deptCode) {
        this.deptCode = deptCode;
    }

    public String getDeptName() {
        return deptName;
    }

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }
}

• 工厂类统一接口

/**
 * 统一的工厂接口
 */
public interface IFactory {
    /**
     * 创建用户实例
     * @return 根据不同的数据库调用，返回相对应的实例
     */
    IUser createUser();

    /**
     * 创建部门实例
     * @return 根据不同的数据库调用，返回相对应的实例
     */
    IDepartment createDepartment();
}

• 具体业务表统一接口

/**
 * 用户统一接口
 */
public interface IUser {
    /**
     * 插入用户
     * @param user
     */
    void insert(User user);

    /**
     * 获取用户信息
     * @return 返回用户信息实体
     */
    User getUser();
}

/**
 * 操作部门实体类的统一接口
 * 根据数据库的不同各自实现自己的业务逻辑
 */
public interface IDepartment {
    /**
     * 插入部门信息
     * @param department
     */
    void insert(Department department);

    /**
     * 获取部门信息
     * @return 返回部门的实体
     */
    Department getDepartment();
}

• 不同数据库具体业务表的实现

/**
 * Access数据库实现
 * User具体业务逻辑
 */
public class AccessUser implements IUser {
    @Override
    public void insert(User user) {
        System.out.println("access database insert user concrete business logical...");
    }

    @Override
    public User getUser() {
        System.out.println("access database get user concrete business logical...");
        return null;
    }
}

/**
 * Access数据库实现
 * Department具体业务逻辑
 */
public class AccessDepartment implements IDepartment {
    @Override
    public void insert(Department department) {
        System.out.println("access database insert department concrete business logical...");
    }

    @Override
    public Department getDepartment() {
        System.out.println("access database get department concrete business logical...");
        return null;
    }
}

/**
 * Oracle 数据库实现
 * User 具体业务逻辑
 */
public class OracleUser implements IUser {
    @Override
    public void insert(User user) {
        System.out.println("oracle database insert user concrete business logical...");
    }

    @Override
    public User getUser() {
        System.out.println("oracle database get user concrete business logical...");
        return null;
    }
}

/**
 * Oracle 数据库实现
 * Department 具体业务逻辑
 */
public class OracleDepartment implements IDepartment {
    @Override
    public void insert(Department department) {
        System.out.println("Oracle database insert department concrete business logical...");
    }

    @Override
    public Department getDepartment() {
        System.out.println("Oracle database get department concrete business logical...");
        return null;
    }
}

• 工厂类的具体实现(不同数据库有各自的实现方式)：

/**
 * AccessDatabase
 */
public class AccessFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new AccessUser();
    }

    @Override
    public IDepartment createDepartment() {
        return new AccessDepartment();
    }
}

/**
 * Oracle
 */
public class OracleFactory implements IFactory {
    @Override
    public IUser createUser() {
        return new OracleUser();
    }

    @Override
    public IDepartment createDepartment() {
        return new OracleDepartment();
    }
}

• 客户端测试代码

public class Client {
    public static void main(String[] args) {
//        IFactory factory = new AccessFactory();
        IFactory factory = new OracleFactory();


        System.out.println("user：");
        IUser user = factory.createUser();
        user.insert(null);
        user.getUser();


        System.out.println("\ndepartment：");
        IDepartment department = factory.createDepartment();
        department.insert(null);
        department.getDepartment();
    }
}

• 运行结果

user：
oracle database insert user concrete business logical...
oracle database get user concrete business logical...

department：
Oracle database insert department concrete business logical...
Oracle database get department concrete business logical...

总结：

优点：

• 1.方便产品系列的替换，由于具体工厂类，在一个应用中只需要在初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。
• 2.它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。

缺点：

• 如果要增加一个项目表Project，那么就需要增加三个类，IProject，AccessProject，OracleProject，还需要改动IFactory，AccessFactory，OracleFactory才可以完全实现。这样是很糟糕的。

不妥之处还请指正...