设计模式-工厂模式

1、简单工厂模式：又叫做静态工厂方法模式，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

 用一个单独的类来做这个创建实例的过程，这就是工厂。

1. 说明：做个比喻，以前我们造车，是由我们自己造车，但现在我们有个车厂来替我们造车了。
2. 优势：使用者无需关心实现，只要告诉工厂需求，由工厂给我们造产品。明确区分了各自的职责和权力，有利于整个软件体系结构的优化。

interface Dao{
    //取得连接
    void getConnection();
}
//Dao产品
class MysqlDao implements Dao{

    @Override
    public void getConnection() {
        // TODO Auto-generated method stub

    }

}
//Dao产品
class OracleDao implements Dao{

    @Override
    public void getConnection() {
        // TODO Auto-generated method stub

    }

}
//Dao工厂
class DaoFactory{
    //创建Dao产品的方法
    public Dao createDao(String dao){
        switch (dao) {
        case "mysql":
            return new MysqlDao();
        case "oracle":
            return new OracleDao();
        }
        default:
            return null;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        //未使用工厂模式，我们自己来创建Dao产品
        MysqlDao mysqlDao = new MysqlDao();
        mysqlDao.getConnection();

        //使用工厂模式，用工厂对象来创建Dao产品
        DaoFactory daoFactory = new DaoFactory();
        //告诉工厂我们的需求，工厂创建产品
        Dao dao = daoFactory.createDao("mysql");
        dao.getConnection();
    }
}

2、工厂方法模式：是简单工厂模式的进一步抽象，抽象了工厂角色，由子类工厂创建产品。

 定义一个用于创建对象的接口，让子类决定实例化哪一个类。
 工厂方法使一个类的实例化延迟到其子类。

1. 说明：现在车厂进一步改革了，分为了福特汽车厂与奔驰汽车厂等等。由具体的车厂创建具体的车
2. 优势：产品类的实现如何变化，调用者都不需要关心，只需关心产品的接口，只要接口保持不变，系统中的上层模块就不会发生变化。
3. 缺点：客户端直接与某一特定的工厂耦合，由此引出抽象工厂模式

interface Dao{
    void getConnection();
}
//Dao产品
class MysqlDao implements Dao{
    @Override
    public void getConnection() {
        // TODO Auto-generated method stub

    }   
}
//Dao产品
class OracleDao implements Dao{
    @Override
    public void getConnection() {
        // TODO Auto-generated method stub

    }
}

//Dao抽象工厂
interface DaoFactory{
    //抽象工厂都有一个创建对应的Dao产品的方法
    Dao createDao();
}

//mysqlDao的工厂
class MysqlDaoFactory implements DaoFactory{
    @Override
    public Dao createDao() {
        // TODO Auto-generated method stub
        return new MysqlDao();
    }
}
//oracleDao的工厂
class OracleDaoFactory implements DaoFactory{
    @Override
    public Dao createDao() {
        // TODO Auto-generated method stub
        return new OracleDao();
    }
}


public class Test {
    public static void main(String[] args) {

        //使用工厂方法模式，用MysqlDao的工厂对象来创建MysqlDao产品
        DaoFactory daoFactory = new MysqlDaoFactory();
        Dao dao = daoFactory.createDao();
        dao.getConnection();

    }
}

3、抽象工厂模式：对工厂方法的工厂再度抽象

interface Dao{
    void getConnection();
}
//Dao产品
class MysqlDao implements Dao{
    @Override
    public void getConnection() {
        // TODO Auto-generated method stub

    }   
}
//Dao产品
class OracleDao implements Dao{
    @Override
    public void getConnection() {
        // TODO Auto-generated method stub

    }
}

//Dao抽象工厂的工厂
class DaoFactoryFactory{
    //抽象工厂都有一个创建对应的Dao产品的方法
    DaoFactory createDaoFactory(String factory){
        switch (factory) {
        case "mysql":
            new MysqlDaoFactory();
        case "oracle":
            return new OracleDaoFactory();
        default:
            return null;
        }


    }
}

//Dao抽象工厂
interface DaoFactory{
    //抽象工厂都有一个创建对应的Dao产品的方法
    Dao createDao();
}

//mysqlDao的工厂
class MysqlDaoFactory implements DaoFactory{
    @Override
    public Dao createDao() {
        // TODO Auto-generated method stub
        return new MysqlDao();
    }
}
//oracleDao的工厂
class OracleDaoFactory implements DaoFactory{
    @Override
    public Dao createDao() {
        // TODO Auto-generated method stub
        return new OracleDao();
    }
}


public class Test {
    public static void main(String[] args) {

        //使用抽象工厂模式，用MysqlDao的工厂对象来创建MysqlDao产品
        DaoFactory daoFactory = new DaoFactoryFactory().createDaoFactory("mysql");
        Dao dao = daoFactory.createDao();
        dao.getConnection();

    }
}

结尾：解决各层耦合的方法一般是再加一层来解决