GOF23之工厂模式Demo

java开发过程中经常使用到工厂模式，下面列出非工厂模式与三种工厂模式的Demo
1.非工厂模式
以Running Car为例

public interface Car {
    void run();
}

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("Audi Running");
    }
}

public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("Byd Running!");
    }
}

public class Client01 {   //调用者
    public static void main(String[] args) {
        Car c1 = new Audi();
        Car c2 = new Byd();
        c1.run();
        c2.run();
    }
}

运行结果
Audi Running!
Byd Running!

2.简单工厂模式（实际中使用最多的工厂模式）
简而言之就是要什么我造什么，全部在一个工厂中实现，所能创建的类只能是事先考虑到的，如果需要添加新的类，则就需要改变工厂类了，这违背了开闭原则。

public class CarFactory {
    public static  Car createCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("比亚迪".equals(type)){
            return new Byd();
        }else{
            return null;
        }
    }
}

public class Client02 {   //调用者
    public static void main(String[] args) {
        Car c1 =CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");
        c1.run();
        c2.run();
    }
}

运行结果：
Audi Running!
Byd Running!

简单工厂的另一种方式

public class CarFactory2 {
    public static  Car createAudi(){
        return new Audi();
    }
    public static  Car createByd(){
        return new Byd();
    }
}

public class Client02 {   //调用者
    public static void main(String[] args) {
        Car c1 = CarFactory2.createAudi();
        Car c2 = CarFactory2.createByd();
        c1.run();
        c2.run();
    }
}

运行结果：
Audi Running!
Byd Running!

3.工厂方法模式
定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。完全实现‘开－闭 原则’，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。
缺点：导致工厂过多。
以Running Car为例

public interface Car {
    void run();
}

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("Audi Running!");
    }
}

public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("Benz Running!");
    }
}

public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("Byd Running!");
    }
}

public interface CarFactory {
    Car createCar();
}

public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Audi();
    }
}

public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

public class BydFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Byd();
    }
}

public class Client {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();
        Car c3 = new BenzFactory().createCar();
        c1.run();
        c2.run();
        c3.run();
    }
}

运行结果
Audi Running!
Byd Running!
Benz Running!

4.抽象工厂模式
以生产汽车为例，生产汽车分为一般汽车和豪华汽车，组装汽车时使用不同的座椅、轮胎、引擎。座椅、轮胎、引擎全部抽象出来，生产汽车的工厂也抽象出来，由不同规格的座椅、轮胎、引擎来实现抽象的座椅、轮胎、引擎，由生产不同汽车的工厂来实现生产汽车。
引擎接口与实现类：

public interface Engine {
    void run();
    void start();
}

class LuxuryEngine implements Engine{
    @Override
    public void run() {
        System.out.println("转速很快!");
    }
    @Override
    public void start() {
        System.out.println("启动快!可以自动启停!");
    }
}

class LowEngine implements Engine{
    @Override
    public void run() {
        System.out.println("转速较慢!");
    }
    @Override
    public void start() {
        System.out.println("启动慢!不能自动启停");
    }
}

座椅接口与实现类:

public interface Seat {
    void massage();
}

class LuxurySeat implements Seat {
    @Override
    public void massage() {
        System.out.println("自动按摩!");
    }
}

class LowSeat implements Seat {
    @Override
    public void massage() {
        System.out.println("不能按摩!");
    }
}

轮胎接口与实现类：

public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("旋转磨损小!");
    }
}

class LowTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("旋转磨损快!");
    }
}

生产汽车的工厂接口:

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

低端汽车工厂的实现类:

public class LowCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }
    @Override
    public Seat createSeat() {
        return new LowSeat();
    }
    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

高端汽车工厂的实现类：

public class LuxuryCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }
    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }
    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

测试:

public class Client {
    public static void main(String[] args) {
        CarFactory  factory = new LuxuryCarFactory();
        Engine e = factory.createEngine();
        e.run();
        e.start();

        CarFactory  factory2 = new LowCarFactory();
        Engine e2 = factory2.createEngine();
        e2.run();
        e2.start();
    }
}

运行结果：
转速很快!
启动快!可以自动启停!
转速较慢!
启动慢!不能自动启停!

以上的Demo可以较为详细的解释了3种工厂模式。实际项目中，简单工厂的使用还是最多的。