GOF设计模式之“工厂模式”

工厂模式实现了创建者和调用者分离。
工厂模式详细分类可以有一下三种：
简单工厂模式
工厂方法模式
抽象工厂模式

1. 简单工厂模式创建对象可以直接通过“工厂类”创建说需要的对象。
   一个Car接口和两个实现类

/**
 * Car接口，带有一个run方法
 * @author 90948
 */
public interface Car {
    void run();
}

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪车");
    }

}

public class BYD implements Car {

    @Override
    public void run() {
        System.out.println("比亚迪车");
    }

}

创建工厂类

/**
 * Car工厂，创建Audi对象和BYD对象
 * @author 90948
 */
public class CarFactory {

    public static Car createCar(String name){
        if("奥迪".equals(name)){
            return new Audi();
        }else if("比亚迪".equals(name)){
            return new BYD();
        }else{
            return null;
        }
    }

}

测试类

public class Test {

    public static void main(String[] args) {
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");

        c1.run();
        c2.run();
    }

}
//结果：
//奥迪车
//比亚迪车

简单工厂模式的缺点：不满足面向对象的基本原则中的“开闭原则”，即开闭原则规定“软件中的对象（类，模块，函数等等）应该对于扩展是开放的，但是对于修改是封闭的。

1. 工厂方法模式：
   同样用Car接口和两个实现类
   不同的是，创建一个CarFactory接口，并且有AudiFactory和BYDFactory实现类。

CarFactory接口

public interface CarFactory {
    Car createCar();
}

实现类：

public class AudiFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new Audi();
    }

}

public class BYDFactory implements CarFactory {

    @Override
    public Car createCar() {
        return new BYD();
    }

}

测试类：

public class Test {

    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BYDFactory().createCar();

        c1.run();
        c2.run();
    }

}
//结果：
//奥迪车
//比亚迪车

优点：符合“开闭原则”。但是使项目的复杂度增加，即扩展是以增加新的类来实现的。

1. 抽象工厂模式
   用来生产不同产品族的全部产品，比如说：生产高端汽车需要高端的发动机，高端的座椅和高端的轮胎，生产低端的汽车需要低端的发动机，低端的座椅和低端的轮胎。代码实现：
   发动机接口以及其高低端发动机实现类：

/**
 * 发动机接口
 * @author 90948
 *
 */
public interface Engine {
    void run();//转速
    void strat();//启动效率
}

/**
 * 高端发动机
 * @author 90948
 *
 */
public class LuxuryEngine implements Engine {

    @Override
    public void run() {
        System.out.println("转速快！");
    }

    @Override
    public void strat() {
        System.out.println("启动快！");
    }

}

/**
 * 低端发动机
 * @author 90948
 */
public class LowerEngine implements Engine {

    @Override
    public void run() {
        System.out.println("转速慢！");
    }

    @Override
    public void strat() {
        System.out.println("启动慢！");
    }

}

座椅接口以及高低端座椅实现类

/**
 * 座椅接口
 * @author 90948
 */
public interface Seat {
    void massage();//是否可以按摩
}

/**
 * 高端座椅
 * @author 90948
 */
public class LuxurySeat implements Seat {

    @Override
    public void massage() {
        System.out.println("高端座椅，可以按摩！");
    }

}

/**
 * 低端座椅
 * @author 90948
 */
public class LowerSeat implements Seat {

    @Override
    public void massage() {
        System.out.println("低端座椅，不可以按摩！");
    }

}

轮胎接口以及高低端轮胎实现类

/**
 * 轮胎接口
 * @author 90948
 */
public interface Tyre {
    void revolve();//是否磨损
}

/**
 * 高端轮胎
 * @author 90948
 *
 */
public class LuxuryTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("高端轮胎，不磨损！");
    }

}

/**
 * 低端轮胎
 * @author 90948
 *
 */
public class LowerTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("低端轮胎，质量差！");
    }

}

制造汽车的工厂接口以及高低端汽车生产的实现类

/**
 * 创建汽车的接口
 * @author 90948
 *
 */
public interface CarFactory {
    Engine createEngine();//创建发动机
    Seat createSeat();//创建座椅
    Tyre createTyre();//创建轮胎
}

/**
 * 制作高端汽车
 * @author 90948
 *
 */
public class LuxuryCar implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }

}

/**
 * 制作低端汽车
 * @author 90948
 *
 */
public class LowerCar implements CarFactory{

    @Override
    public Engine createEngine() {
        return new LowerEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowerSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowerTyre();
    }

}

测试类，生产一辆高端汽车：

/**
 * 测试类，制作一辆高端汽车
 * @author 90948
 */
public class Test {

    public static void main(String[] args) {
        CarFactory factory = new LuxuryCar();
        Engine engine = factory.createEngine();
        Seat seat = factory.createSeat();
        Tyre tyre = factory.createTyre();

        engine.run();
        engine.strat();
        seat.massage();
        tyre.revolve();
    }

}
//结果：
//转速快！
//启动快！
//高端座椅，可以按摩！
//高端轮胎，不磨损！

应用的场景主要有：
1. JDBC中Connection对象的获取。
2. Hibernate中通过SessionFactory创建Session
3. Spring中IoC容器创建管理Bean。
等等……