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

前面我们介绍了工厂设计模式知道了工厂模式可以降低程序的耦合度
下面我们介绍下抽象工厂设计模式
1.同样我们需要实体类即我们的产品代码如下

工厂产品客车

public abstract class AbstractBus {
public abstract String getRunSpeed();//奔跑的速度
public abstract int getPeopleCount();//承载的人数
}

工厂产品汽车

public abstract class AbstractCar {
public abstract String getRunSpeed();//奔跑的速度
public abstract int getPeopleCount();//承载的人数
}

好了我们的产品有了接下来依然是我们的工厂

2.生产产品的工厂

public abstract class AbstractFactory {
   public abstract AbstractCar getCar();//获取car
   public abstract AbstractBus getBus();//获取bus

   public static AbstractFactory getFactoryByType(String type){
       switch(type){
       case "f1":
           return new Factory1();
       case "f2":
           return new Factory2();
       default:
           return null;
       }
   }
}

同样我们发现我们的抽象工厂有工厂模式的方法getFactoryByType通过传递的类型返回相应的对象跟以往工厂模式不同的是我们返回的不是具体的car,bus而是返回了一个工厂实例
再看我们的具体工厂代码如下
工厂Factory1

public class Factory1 extends AbstractFactory {
    @Override
    public AbstractCar getCar() {
        return new AbstractCar(){
            @Override
            public String getRunSpeed() {
                return "170km/h";
            }
            @Override
            public int getPeopleCount() {
                return 6;
            }
        };
    }

    @Override
    public AbstractBus getBus() {
        return new AbstractBus(){
            @Override
            public String getRunSpeed() {
                return "100km/h";
            }
            @Override
            public int getPeopleCount() {
                return 30;
            }
        };
    }
}

工厂Factory2

public class Factory2 extends AbstractFactory {
    @Override
    public AbstractCar getCar() {
        return new AbstractCar(){
            @Override
            public String getRunSpeed() {
                return "180km/h";
            }
            @Override
            public int getPeopleCount() {
                return 4;
            }
        };
    }

    @Override
    public AbstractBus getBus() {
        return new AbstractBus(){
            @Override
            public String getRunSpeed() {
                return "150km/h";
            }
            @Override
            public int getPeopleCount() {
                return 35;
            }
        };
    }
}

3.最后就是我们的客户从工厂购买汽车的方法了
代码如下：

public class Test {
    public static void main(String[] args) {
        AbstractFactory factory=AbstractFactory.getFactoryByType("f1");
        String speed=factory.getBus().getRunSpeed();
        System.out.println("速度为"+speed);
    }
}

升级

抽象抽象工厂类去掉具体生产工厂过程

public abstract class AbstractFactory {
   public abstract AbstractCar getCar();//获取car
   public abstract AbstractBus getBus();//获取bus
}

调用

public class Test {
    public static void main(String[] args) {
        Factory1 factory=new Factory1();
        String speed=factory.getBus().getRunSpeed();
        System.out.println("速度为"+speed);
    }
}

升级原则 ： 约定优于配置

约定优于配置（convention over configuration），也称作按约定编程，是一种软件设计范式，旨在减少软件开发人员需做决定的数量，获得简单的好处，而又不失灵活性。

优点
1.隔离具体类的生产交给具体工厂生产
2.增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”。
3.当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点
1.在产品族中扩展新的产品是很困难的，它需要修改抽象工厂的接口 体现了“开闭原则”的倾斜性