五、创建型模式之工厂模式

总述

工厂模式中又分为简单工厂模式，工厂方法模式，抽象工厂模式

简单工厂模式

简单工厂模式是最简单的，就是根据不同的参数值来生产不同的对象
这里简单说明一下下面列举的类中： AbstractCar 是抽象类，VanCar和MiniCar是AbstarctCat的子类，就不在放这几个类了

/**
 * 简单工厂模式
 * 这里简单说明一下 AbstractCar 是抽象类Car，VanCar和MiniCar是AbstarctCat的 
 *  子类，就不在放这几个类了
 */
public class SimpleFactory {
    /**
     *
     * @param type  根据传参type来生产不同品种的车
     * @return AbstractCar 实例
     */
    public AbstractCar newCar(String type){
        //这里就是简单工厂的核心方法的核心操作
        if("van".equals(type)){
            return new VanCar();
        }else if("mini".equals(type)){
            return new MiniCar();
        }
        //如果要添加更多的产品，则必须修改newCar方法，违反开闭原则。应该直接扩展出一个类来造
        return null;
    }
}

在main方法中通过传不通过的type来生成不同的实例

public class MainTest {
    public static void main(String[] args) {
        // 通过传递不同的参数值生成不同的Car
        SimpleFactory factory = new SimpleFactory();
        AbstractCar van = factory.newCar("van");
        AbstractCar mini = factory.newCar("mini");
    }
}

工厂方法模式

抽象工厂类不生产对象，只定义生产对象的抽象方法，交由子类实现父类的抽象方法，生成指定的对象

/**
 * 抽象工厂的层级
 */
public abstract class AbstractCarFactory {
   //只定义生产汽车的抽象方法，交由下级子类实现抽象方法
    public abstract AbstractCar newCar();
}

/**
 * 实现抽象工厂，只生产指定的对象
 */
public class MinCarFactory extends AbstractCarFactory{
    @Override
    public AbstractCar newCar() {
        return new MiniCar();
    }
}

public class VanCarFactory extends AbstractCarFactory {
    @Override
    public AbstractCar newCar() {
        return new VanCar();
    }
}

public class MainTest {

    public static void main(String[] args) {
        AbstractCarFactory carFactory = new VanCarFactory();
       //这个生产出来的就是VanCar
        AbstractCar abstractCar = carFactory.newCar();

        carFactory = new MiniCarFactory();
        //这个生产出来的就是MiniCar
        AbstractCar abstractCar1 = carFactory.newCar();
    }
}

抽象工厂模式

说句实话，从目前整理的资料来看，抽象工厂模式就是工厂方法模式一个简单升级，工厂方法模式中原来一个工厂只生产一种对象，现在抽象工厂模式变成了生产多种对象，感觉就是层层递进，也就是说抽象工厂模式如果只生成有一个对象的话就会退化成工厂方法墨水，下面就放一下代码

/**
 * 简单举个例子，生产两种对象，一种是车，一种是口罩
 */
public abstract class WulinFactory {
    abstract AbstractCar newCar();
    abstract AbstractMask newMask();
}

这里其实举另一个例子比较好一点,假如咱们操作数据库的时候需要先获取连接Connection,然后通过连接发送命令Command，那么我们来创建一个抽象工厂IDataBaseUtil

/**
* 这个接口就是抽象工厂顶级接口类
*/
public Interface IDataBaseUtil {
    //获得连接
    IConnection getConnection();
    //获得命令
    ICommand getCommand();
}

实际开发中的话，我们可能使用mysql也可能使用oracle，这里我们假设使用mysql

/**
*  mysql的连接对象
*/
class MysqlConnection implements IConnection{
    @Override  
    public void connection(){
       //建立mysql连接
      }
}
class MysqlCommand implements ICommand{
    @Override  
    public void command(){
       //发送mysql命令
      }
}

/**
*  MysqlDataBaseUtil 实现抽象工厂接口 IDataBaseUtil，并实现获取连接和获取命令的对象
*/
class MysqlDataBaseUtil implements IDataBaseUtil{
        //获得连接
    IConnection getConnection(){
        return new MysqlConnection();
    };
    //获得命令
    ICommand getCommand(){
         return new MysqlCommand();
    };
}

// 测试类
public class MainTest {

    public static void main(String[] args) {
       //创建mysql数据源类，获取连接，获取命令
       IDataBaseUtil factory = new MysqlDataBaseUtil();
       IConnection connection= factory.getConnection();
       connection.connection();  
        ICommand  command = new MysqlCommand();
        command.command();
    }
}

这里模拟的是框架中使用不同数据源的情况，可以使用mysql，也可以使用oracle，如果使用oracle的话，可能就是实现一个OracleDataBaseUtil就可以了，IDataBaseUtil factory = new OracleDataBaseUtil()（这里提一下，框架中这种的话，一定是通过反射来获取的，所以是不需要修改代码的）
<完结>

五、创建型模式之工厂模式