设计模式（抽象工厂模式）

抽象工厂模式介绍及应用场景

源码下载地址
抽象工厂模式从个人理解上来说适应的场景就是我们所做的事情有相同的也有不同的地方，例如：造飞机，造火车，造汽车
相同的地方我们都可以造轮子，车身，但是造飞机得造跑道，造机翼，造火车得造铁轨，汽车得造铁轨，造汽车就要汽车工厂，造火车需要火车工厂，造飞机需要飞机制造厂，
其实工厂模式就是工厂的工厂

从上层看 我们需要一个工厂的工厂FactoryProducer

package com.jvm.抽象工厂模式;

import com.jvm.抽象工厂模式.工厂.抽象工厂;
import com.jvm.抽象工厂模式.工厂.汽车工厂;
import com.jvm.抽象工厂模式.工厂.火车工厂;
import com.jvm.抽象工厂模式.工厂.飞机工厂;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class FactoryProducer {
    public FactoryProducer() {
        new 火车工厂();
        new 汽车工厂();
        new 飞机工厂();
    }

    private static Map<String, 抽象工厂> strategyMap = new ConcurrentHashMap<>();

    public static void register(String name, 抽象工厂 handler) {
        strategyMap.put(name, handler);
    }

    public  抽象工厂 getInvokeStrategy(String name) {
        return strategyMap.get(name);
    }
}

首先需要将飞机工厂，汽车工厂，火车工厂都注册到 工厂生产者中，需要map存储所有工厂，工厂的注册在每个工厂中，getInvokeStrategy通过名称获取那个工厂

package com.jvm.抽象工厂模式.工厂;

import com.jvm.工厂模式.大巴;
import com.jvm.工厂模式.小轿车;
import com.jvm.工厂模式.货车;
import com.jvm.工厂模式.造车接口;
import com.jvm.抽象工厂模式.FactoryProducer;
import com.jvm.抽象工厂模式.工厂Enum;
import com.jvm.抽象工厂模式.火车.火车接口;
import com.jvm.抽象工厂模式.飞机.飞机接口;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class 汽车工厂 extends 抽象工厂{
    public 汽车工厂() {
        new 小轿车();
        new 货车();
        new 大巴();
        FactoryProducer.register(工厂Enum.CAR.getCode(),this);
    }

    private static Map<String, 造车接口> strategyMap = new ConcurrentHashMap<>();

    public static void register(String name, 造车接口 handler) {
        strategyMap.put(name, handler);
    }

    public static 造车接口 getInvokeStrategy(String name) {
        return strategyMap.get(name);
    }

    @Override
    public 飞机接口 造飞机(String name) {
        return null;
    }

    @Override
    public 火车接口 造火车(String name) {
        return null;
    }

    @Override
    public 造车接口 造汽车(String name) {
        return getInvokeStrategy(name);
    }
}

package com.jvm.抽象工厂模式.工厂;

import com.jvm.工厂模式.大巴;
import com.jvm.工厂模式.小轿车;
import com.jvm.工厂模式.货车;
import com.jvm.工厂模式.造车接口;
import com.jvm.抽象工厂模式.FactoryProducer;
import com.jvm.抽象工厂模式.工厂Enum;
import com.jvm.抽象工厂模式.火车.和谐号;
import com.jvm.抽象工厂模式.火车.火车接口;
import com.jvm.抽象工厂模式.火车.绿皮车;
import com.jvm.抽象工厂模式.飞机.飞机接口;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class 火车工厂 extends 抽象工厂 {
    public 火车工厂() {
        new 和谐号();
        new 绿皮车();
        FactoryProducer.register(工厂Enum.TRAIN.getCode(), this);
    }

    private static Map<String, 火车接口> strategyMap = new ConcurrentHashMap<>();

    public static void register(String name, 火车接口 handler) {
        strategyMap.put(name, handler);
    }

    public static 火车接口 getInvokeStrategy(String name) {
        return strategyMap.get(name);
    }

    @Override
    public 飞机接口 造飞机(String name) {
        return null;
    }

    @Override
    public 火车接口 造火车(String name) {
        return getInvokeStrategy(name);
    }

    @Override
    public 造车接口 造汽车(String name) {
        return null;
    }
}

package com.jvm.抽象工厂模式.工厂;

import com.jvm.工厂模式.造车接口;
import com.jvm.抽象工厂模式.FactoryProducer;
import com.jvm.抽象工厂模式.工厂Enum;
import com.jvm.抽象工厂模式.火车.火车接口;
import com.jvm.抽象工厂模式.飞机.直升机;
import com.jvm.抽象工厂模式.飞机.轰炸机;
import com.jvm.抽象工厂模式.飞机.飞机接口;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class 飞机工厂 extends 抽象工厂 {
    public 飞机工厂() {
        new 轰炸机();
        new 直升机();
        FactoryProducer.register(工厂Enum.PLAIN.getCode(), this);
    }

    private static Map<String, 飞机接口> strategyMap = new ConcurrentHashMap<>();

    public static void register(String name, 飞机接口 handler) {
        strategyMap.put(name, handler);
    }

    public static 飞机接口 getInvokeStrategy(String name) {
        return strategyMap.get(name);
    }

    @Override
    public 飞机接口 造飞机(String name) {
        return getInvokeStrategy(name);
    }

    @Override
    public 火车接口 造火车(String name) {
        return null;
    }

    @Override
    public 造车接口 造汽车(String name) {
        return null;
    }
}

所有工厂同时实现了抽象接口

package com.jvm.抽象工厂模式.工厂;

import com.jvm.工厂模式.造车接口;
import com.jvm.抽象工厂模式.火车.火车接口;
import com.jvm.抽象工厂模式.飞机.飞机接口;

public abstract class 抽象工厂 {
    public abstract 飞机接口 造飞机(String name);

    public abstract 火车接口 造火车(String name);

    public abstract 造车接口 造汽车(String name);

}

我们只需在每个工厂实现自己的方法就可以了

在汽车工厂中造不同的车型，火车飞机类似，只贴汽车工厂实现代码

package com.jvm.抽象工厂模式.汽车;

import com.jvm.CarEnum;
import com.jvm.工厂模式.Factory;
import com.jvm.工厂模式.造车接口;

public class 大巴 implements 造车接口 {

    public 大巴() {
        Factory.register(CarEnum.BUS.getId(), this);
    }

    @Override
    public void 造轮子() {
        System.out.println("大轮子");
    }

    @Override
    public void 造车身() {
        System.out.println("大车架");
    }

    @Override
    public void 造车座() {
        System.out.println("大巴车座");
    }

    @Override
    public void 造发动机() {
        System.out.println("大巴发动机");
    }
}

package com.jvm.抽象工厂模式.汽车;

import com.jvm.CarEnum;
import com.jvm.工厂模式.Factory;
import com.jvm.工厂模式.造车接口;

public class 小轿车 implements 造车接口 {
    public 小轿车() {
        Factory.register(CarEnum.CAR.getId(), this);
    }
    @Override
    public void 造轮子() {
        System.out.println("小轮子");
    }

    @Override
    public void 造车身() {
        System.out.println("小车架");
    }

    @Override
    public void 造车座() {
        System.out.println("轿车车座");
    }

    @Override
    public void 造发动机() {
        System.out.println("小车发动机");
    }
}

package com.jvm.抽象工厂模式.汽车;

import com.jvm.CarEnum;
import com.jvm.工厂模式.Factory;
import com.jvm.工厂模式.造车接口;

public class 货车 implements 造车接口 {
    public 货车() {
        Factory.register(CarEnum.TRUCK.getId(), this);
    }
    @Override
    public void 造轮子() {
        System.out.println("大轮子");
    }

    @Override
    public void 造车身() {
        System.out.println("货车架");
    }

    @Override
    public void 造车座() {
        System.out.println("货车座位");
    }

    @Override
    public void 造发动机() {
        System.out.println("货车发动机");
    }
}

同时也有一个接口类

package com.jvm.抽象工厂模式.汽车;

public interface 造车接口 {
    void 造轮子();
    void 造车身();
    void 造车座();
    void 造发动机();
}

抽象工厂模式就完成了 ，其实就是两个工厂模式嵌套
运行查看结果

package com.jvm.抽象工厂模式;

import com.jvm.CarEnum;
import com.jvm.抽象工厂模式.工厂.抽象工厂;
import com.jvm.抽象工厂模式.火车.火车接口;
import com.jvm.抽象工厂模式.飞机.飞机接口;

public class 主类 {
    public static void main(String[] args) {
        //首先要获取制造工厂，是飞机 火车 汽车
        FactoryProducer producer=new FactoryProducer();
        抽象工厂 factory = producer.getInvokeStrategy(工厂Enum.PLAIN.getCode());
        飞机接口 feiji = factory.造飞机(CarEnum.BOMBER.getId());
        feiji.机场();
        feiji.机翼();
        飞机接口 feiji2 = factory.造飞机(CarEnum.HELICOPTER.getId());
        feiji2.机场();
        feiji2.机翼();
        抽象工厂 factory2 = producer.getInvokeStrategy(工厂Enum.TRAIN.getCode());
        火车接口 huoche1 = factory2.造火车(CarEnum.HARMONY.getId());
        huoche1.火车站();
        huoche1.铁轨();
        火车接口 huoche2 = factory2.造火车(CarEnum.GREENLEATHERCAR.getId());
        huoche2.火车站();
        huoche2.铁轨();
        //其次我们要根据工厂造想要的具体型号 例如 直升机，轰炸机，航天飞机等
    }
}

运行结果

军用机场
高级机翼
普通机场
螺旋桨
高铁火车站
铁轨
普通火车站
小型铁腿

Process finished with exit code 0

到此抽象工厂模式完成