设计模式04-抽象工厂模式

介绍

---

抽象工厂模式就是一个超级工厂，创建者其他工厂。在这个模式中，接口是负责创建一个相关的工厂类，不需要显示指定它的类

何时使用：当产品有多于一个的产品族，需要通过不同的工厂来生产不同的产品族。

关键部分：定义一个抽象类或接口为超级工厂，里面聚合了其他产品族的接口方法

优点：一个产品族的多个对象都被设计成一起工作，能保证客户端使用的是同一个产品族的对象

缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码

核心思想

1. 该模式，我们分为超级工厂类，工厂类，产品父类，产品子类，使用者类，工厂创造器类
2. 超级工厂类是抽象类，里面的抽象方法为返回产品父类。不同工厂类通过继承覆写超级工厂类的不同方法，来实现一个产品族。其他类与工厂模式一致。
3. 按需求分析，如果需要的话，可以创建一个工厂创造器，根据传递类型信息来返回对应工厂

示例

小故事：
首先我会讲个小故事，用于串联这次的类。

有一个超级经销商（超级工厂），特别厉害。它不仅售卖车，还售卖飞机，而且飞机和车不仅售卖一种款式。于是，有一个亿万富翁就来到这家经销商。经销商问富翁，你要车还是要飞机啊。
富翁说，我要车。然后经销商就带富翁去了售卖车的车间（产品工厂）。富翁说：给我来辆宝马吧。宝马由车间的员工开到它面前给他。富翁看看了，又说：再给我来辆奔驰吧，然后车间员工又开奔驰车到它面前。
富翁说：我想去飞机的车间看看，然后经销商带富翁去了飞机的车间（产品工厂）。富翁先看了海上飞机，有看了直升飞机。觉得不错，全部都买了。

当然，这只是为了方便理解编的一个小故事。
所以这个故事里，有一个超级经销商(超级工厂类)，选择去哪个车间的类(工厂创造类)，车间(工厂类)，车（产品父类），宝马奔驰(产品子类)，飞机场(工厂类)，飞机(另一个产品父类)，直升飞机和海上飞机(产品子类)，以及亿万富翁(使用者类) 九种类别

这就是一个完整的抽象工厂模式，由一个超级工厂和若干个子工厂组成，子工厂各自生产神似，但实际不同的产品

超级工厂类

public abstract class SuperFactory {

    public abstract Airplane getAirPlane(String type);
    public abstract Car getCar(String type);
}

子工厂类

public class CarFactory extends SuperFactory{

    @Override
    public Airplane getAirPlane(String type) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public Car getCar(String type) {
        if(type.equals("benZ")){
            return new BenZ();
        }else if(type.equals("bmw")){
            return new BMW();
        }else{
            return new Volkswagen();
        }
    }

}

public class AirplaneFactory extends SuperFactory{

    @Override
    public Airplane getAirPlane(String type) {
        if(type.equals("seaPlane")){
            return new Seaplane();
        }else if(type.equals("monoPlane")){
            return new MonoPlane();
        }else{
            return new Helicopter();
        }
    }

    @Override
    public Car getCar(String type) {
        return null;
    }

}

产品父类

public interface Car {

    public void run();
}

public interface Airplane {

    public void fly();
}

产品子类

public class BenZ implements Car{

    @Override
    public void run() {
        System.out.println("我是奔驰");
    }

}

public class BMW implements Car {

    @Override
    public void run() {
        System.out.println("我是宝马");
    }

}

public class Volkswagen implements Car {

    @Override
    public void run() {
        System.out.println("我是大众");
    }

}

public class Seaplane implements Airplane{

    @Override
    public void fly() {
        System.out.println("我是海上飞机");
    }

}

public class MonoPlane implements Airplane{

    @Override
    public void fly() {
        System.out.println("我是单翼飞机");

    }

}

public class Helicopter implements Airplane{

    @Override
    public void fly() {
        System.out.println("我是直升飞机");

    }

}

工厂创造类

public class FactoryProducer {

    public static SuperFactory getFactory(String type){
        if(type.equalsIgnoreCase("car")){
             return new CarFactory();
        } else if(type.equalsIgnoreCase("airplane")){
            return new AirplaneFactory();
        }
        return null;
    }
}

使用者类

public class Zillionaire {
    public static void main(String[] args) {
        SuperFactory superFactory = FactoryProducer.getFactory("car");
        Car car1 = superFactory.getCar("bmw");
        car1.run();
        car1 = superFactory.getCar("benZ");
        car1.run();
        superFactory = FactoryProducer.getFactory("airPlane");
        Airplane plane = superFactory.getAirPlane("seaPlane");
        plane.fly();
        plane = superFactory.getAirPlane("helicopter");
        plane.fly();
    }
}