工厂模式（实现创建者和调用者的分离，实现解耦）

　　本质：实例化对象，用工厂方法代替new()操作；

　　　　　将选择实现类、创建对象统一管理和控制；从而实现将调用者和实现类解耦；

　　分类：

　　　　　简单工厂：用来生产统一等级结构中的任何产品（对于增加新的产品，需要修改已有的代码）

　　　　　工厂方法：用来生产同一等级中的固定产品（对于增加新的产品，不需要修改已有的代码）

　　　　　抽象工厂模式：用来生产不同产品族的全部产品（对于增加新的产品无能为力，但是支持增加产品族）

 

　　记得之前参与过的一个产品，根据不同的公司的需求，我们需要通过修改配置文件，从而连接到不同的数据库，支持DB2，mysql，Orical，那个实现就是用简单工厂来实现。现在简单来模拟一下：

　简单工厂：

　　简单工厂的缺点在于：如果我需要添加支持DB2的数据库，需要修改原有的代码！

/** * 
 * Database 实体接口 * 
*/public interface Database {    void getDatabase();}

/** * 
 * MysqlDB Mysql数据库连接实体 * 
*/public class MysqlDB implements Database{    @Override    public void getDatabase() {        System.out.println("连接到mysql数据库");    }}

/** * 
 * OricalDB Orical数据库连接实体 * 
 */public class OricalDB implements Database {    @Override    public void getDatabase() {        System.out.println("连接到orical数据库");    }}

/** * 
 * DBFactory 数据库连接工厂类 * 
*/public class DBFactory {    /**     * 创建mysql连接实体     * @return     */    public static Database connectionMysql(){        return new MysqlDB();    }    /**     * 创建orical连接实体     * @return     */    public static Database connectionOrical(){        return new OricalDB();    } }

/** * 
 * Client 测试类 * 
 */public class Client {    public static void main(String[] args) {        Database orical = DBFactory.connectionOrical();        Database mysql = DBFactory.connectionMysql();        orical.getDatabase();        mysql.getDatabase();    }}

　工厂方法　

　  工厂方法模式和简单工厂模式最大的区别在于，简单工厂只有一个工厂类，但是工厂方法模式有一组实现了相同接口的工厂类，从而保证添加新产品，只需要通过增加新类即可，不需要修改原有代码！现在我们用工厂方法模式实现上面的需求：

　　首先添加如上三个类：Database、MysqlDB、OricalDB。再添加如下类：

/** * 
 * DBFactory 工厂类接口 * 
 */public interface DBFactory {    Database connectionDB();}

/** * 
 * MysqlDBFactory mysql工厂类接口类现类 * 
 */public class MysqlDBFactory implements DBFactory {    @Override    public Database connectionDB() {        return new MysqlDB();    }}

/** * 
 * OricalDBFactory Orical工厂类接口类现类 * 
 */public class OricalDBFactory implements DBFactory{    @Override    public Database connectionDB() {        return new OricalDB();    }}

/** * 
 * Client 工厂方法 实现工厂模式测试类 * 
*/public class Client {    public static void main(String[] args) {        Database orical = new OricalDBFactory().connectionDB();        Database mysql = new MysqlDBFactory().connectionDB();        orical.getDatabase();        mysql.getDatabase();    }}

　抽象工厂模式

　　抽象工厂模式是工厂方法的升级版本，在多个业务品种、业务分类（即不同产品族）时，通过抽象工厂模式生产需要的对象是一种非常好的解决办法。

　　所谓的产品族，是指位于不同产品等级结构中功能相关联的产品组成的家族。比如：汽车有高档、低档之分，具体来说是高档车配备了高端的引擎、高端轮胎...，而低档车配备了低端的引擎、低端的轮胎；那么轮胎、引擎就是两个产品族。

　　工厂类生产出高档车就应该配备高端引擎和轮胎；低档车就应该配备低端的引擎和轮胎。下面我们来试试这个例子：

　　

/** * Engine 引擎接口*/public interface Engine {    void run();}/** * 高端引擎 */class HighEngine implements Engine{    @Override    public void run() {        System.out.println("高端发动机，跑的就是快...");    }}/** * 低端引擎 */class LowEngine implements Engine{    @Override    public void run() {        System.out.println("低端发动机，跑的好慢...");    }}

/** * 轮胎类接口  */public interface Tyre {    void skidproof();}/** * 高端轮胎 */class HighTyre implements Tyre{    @Override    public void skidproof() {        System.out.println("高端轮胎就是防滑的...");    }}/** * 低端轮胎 */class LowTyre implements Tyre{    @Override    public void skidproof() {        System.out.println("低端轮胎是不防滑的...");    }}

/** * 汽车工厂接口 */public interface CarFactory {    //创建引擎    Engine creatEnginer();    //创建轮胎    Tyre createTyre();}/** * 高端汽车工厂 */class HighCarFactory implements CarFactory{    @Override    public Engine creatEnginer() {        return new HighEngine();    }    @Override    public Tyre createTyre() {        return new HighTyre();    }}/** * 低端汽车工厂 */class LowCarFactory implements CarFactory{    @Override    public Engine creatEnginer() {        return new LowEngine();    }    @Override    public Tyre createTyre() {        return new LowTyre();    }  }

/** * 抽象工厂测试类 */public class Client {    public static void main(String[] args) {        CarFactory highCarFactory = new HighCarFactory();        Engine engine = highCarFactory.creatEnginer();        Tyre tyre = highCarFactory.createTyre();        engine.run();        tyre.skidproof();    }}