工厂模式

简单工厂

用一个工厂类负责产品的创建。接收一个参数，输出具体的产品对象。
例如一个生产汽车的工厂，可以根据汽车的类型生产公车、卡车等。

public abstract class Car {
    public abstract void produce();
}

class Bus extends Car {
    @Override
    public void produce() {
        System.out.println("生成了一辆公车");
    }
}

class Truck extends Car {
    @Override
    public void produce() {
        System.out.println("生成了一辆货车");
    }
}

class CarFactory {
    public Car getCar(String type){
        if("bus".equalsIgnoreCase(type)){
            return new Bus();
        }else if("truck".equalsIgnoreCase(type)){
            return new Truck();
        }
        throw new RuntimeException("错误类型！");
    }
}

class Test {
    public static void main(String[] args) {
        CarFactory carFactory = new CarFactory();
        carFactory.getCar("bus").produce();

        carFactory.getCar("truck").produce();

        carFactory.getCar("suv").produce();
    }
}

简单工厂严格来说不是GoF设计模式中的一个，但是它是工厂方法、抽象工厂的基础。

简单工厂不符合开闭原则，如果要增加新的车的种类，必须修改CarFactory。

工厂方法

工厂方法相对于简单工厂来说，扩展新的产品种类时，不需要修改原有代码。一个工厂负责一个产品类的创建。

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

public abstract class Car {
    public abstract void produce();
}

class Bus extends Car{
    @Override
    public void produce() {
        System.out.println("生产了一辆公车");
    }
}

class Truck extends Car {
    @Override
    public void produce() {
        System.out.println("生产了一辆卡车");
    }
}

class Van extends Car {
    @Override
    public void produce() {
        System.out.println("生产了一辆厢形车");
    }
}

public abstract class CarFactory {
    public abstract Car getCar();
}

class BusFactory extends CarFactory{
    @Override
    public Car getCar() {
        return new Bus();
    }
}

class TruckFactory extends CarFactory {
    @Override
    public Car getCar() {
        return new Truck();
    }
}

class VanFactory extends CarFactory {
    @Override
    public Car getCar() {
        return new Van();
    }
}

public class Test {
    public static void main(String[] args) {
        BusFactory f1 = new BusFactory();
        TruckFactory f2 = new TruckFactory();
        VanFactory f3 = new VanFactory();
        f1.getCar().produce();
        f2.getCar().produce();
        f3.getCar().produce();
    }
}

抽象工厂

抽象工厂是对简单工厂的改进，可以将简单工厂和工厂方法整合。

定义：为创建一组相关或相互依赖的对象提供一个接口，而无须指定它们的具体类。 当一个类别的产品有多个系列区分时，为了按照系列生产商品，使用抽象工厂区分。

例如车的两个重要部件是轮胎和发动机。在工厂方法的基础上加以改造:

public abstract class Engine {
    public abstract void produce();
}


class BusEngine extends Engine {
    @Override
    public void produce() {
        System.out.println("公车发动机");
    }
}

class TruckEngine extends Engine {
    @Override
    public void produce() {
        System.out.println("货车发动机");
    }
}

class VanEngine extends Engine {
    @Override
    public void produce() {
        System.out.println("厢式车发动机");
    }
}

public abstract class Tyre {
    public abstract void produce();
}


class BusTyre extends Tyre {
    @Override
    public void produce() {
        System.out.println("公车大轮胎");
    }
}

class TruckTyre extends Tyre {
    @Override
    public void produce() {
        System.out.println("货车八轮胎");
    }
}

class VanTyre extends Tyre {
    @Override
    public void produce() {
        System.out.println("厢式车不漏气轮胎");
    }
}

public interface CarFactory {
    Tyre getTyre();

    Engine getEngine();
}

class BusFactory implements CarFactory{

    @Override
    public Tyre getTyre() {
        return new BusTyre();
    }

    @Override
    public Engine getEngine() {
        return new BusEngine();
    }
}

class TruckFactory implements CarFactory{

    @Override
    public Tyre getTyre() {
        return new TruckTyre();
    }

    @Override
    public Engine getEngine() {
        return new TruckEngine();
    }
}

class VanFactory implements CarFactory{

    @Override
    public Tyre getTyre() {
        return new VanTyre();
    }

    @Override
    public Engine getEngine() {
        return new VanEngine();
    }
}

public class Test {
    public static void main(String[] args) {
        CarFactory factory = new BusFactory();
        factory.getTyre().produce();
        factory.getEngine().produce();

        factory = new TruckFactory();
        factory.getTyre().produce();
        factory.getEngine().produce();

        factory = new VanFactory();
        factory.getTyre().produce();
        factory.getEngine().produce();
    }
}

抽象工厂不太容易扩展新的产品，比如新增了一个跑车（Sports Car），要新增SportsCarFactory，以及对应的轮胎(Tyre）和发动机（Engine）。类的数量和层次变得更复杂。
优点是切换产品簇比较容易，比如给公车换上货车的发动机。

class BusFactory implements CarFactory{

    @Override
    public Tyre getTyre() {
        return new BusTyre();
    }

    @Override
    public Engine getEngine() {
        return new TrunkEngine();
    }
}