抽象工厂模式

【抽象工厂模式应用场景举例】
写到抽象工厂模式了，我深知“抽象工厂模式”博文会带来一点点高潮，因为程序员对工厂模式中的“抽象工厂”都是比较感冒的，而且关注也很多，我就尽量用我所能理解的那么点程度来给大家介绍这个模式，如果有更好的比喻还请网友指正，先感谢了！
　　设计模式-快餐简解-【工厂方法模式】
    介绍了工厂方法的使用，从那个程序中可以看到，奥迪audi车是从audi_car_factory_imple工厂中创建出来的，而大众3W车是从threeW_car_factory_imple工厂中创建出来的，那么如果这2家汽车生产大厂由总部在北京市，现在发展到上海，深圳等城市创建生气汽车的分厂，该怎么办？是不是得将原来的奥迪汽车工厂类：
public class audi_car_factory_imple implements Icar_factory {

    public Icar_interface create_car() {

        car_audi_imple car_audi_imple_ref = new car_audi_imple();
        car_audi_imple_ref.setName("奥迪A6");
        car_audi_imple_ref.setSpeed(300);

        return car_audi_imple_ref;
    }
}
    改成类似如下的模样：
public class audi_car_factory_imple implements Icar_factory {

    public Icar_interface create_car(String area_car) {

if (area_car.equals("北京")){创建一个北京的奥迪汽车}

if (area_car.equals("上海")){创建一个上海的奥迪汽车}

if (area_car.equals("深圳")){创建一个深圳的奥迪汽车}

        return car_audi_imple_ref;
    }
}
    那么发现一个问题，不同地域的汽车却在一个工厂中出现，这是不合乎常理的，因为北京奥迪在北京分厂创建，上海奥迪在上海分厂创建，这样才对。
    所以如果遇到分“大系”来创建对象的时候，抽象工厂方法是肯定要使用的时候了。这里的大系指的就是从地域上来分。
    这个例子就应该以“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”
比如在玩“极品飞车”这款游戏，每个地图处都有造车的工厂，每个造车的工厂都因为有造车的档次不同而划分为高级车厂，低级车厂，那么这样的场景正是应用抽象工厂的好时机，再来理解一下这句话“用抽象工厂来定义具体工厂的抽象，而由具体工厂来创建对象”，用抽象造车工厂来定义具体造车工厂的抽象，而由具体的造车工厂来创建汽车，这就是抽象工厂与工厂方法的不同，工厂方法中对象的创建是由工厂方法来确定的，创建的对象都是不分类并且实现一个接口的，而抽象工厂就是在工厂方法的基础上对创建车的对象的行为进行分类，比如北京车厂，上海车厂等。
类型：创建模式
    提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。


    【抽象工厂模式-JAVA代码实现】
    新建抽象工厂接口：
package car_factory_interface;

import car_interface.Icar_interface;

public interface Icar_factory {

    public Icar_interface create_threeW_car();

    public Icar_interface create_audi_car();

}
    新建抽象工厂接口的高级车adv工厂实现类：
package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple_adv;
import car_imple.car_audi_imple_adv;
import car_interface.Icar_interface;

public class car_factory_adv implements Icar_factory {

    public Icar_interface create_audi_car() {

        car_audi_imple_adv car_audi_imple_adv = new car_audi_imple_adv();
        car_audi_imple_adv.setName("奥迪A6");
        car_audi_imple_adv.setSpeed(300);

        return car_audi_imple_adv;
    }

    public Icar_interface create_threeW_car() {

        car_3w_imple_adv car_3w_imple_adv_ref = new car_3w_imple_adv();
        car_3w_imple_adv_ref.setName("大众A6");
        car_3w_imple_adv_ref.setSpeed(300);

        return car_3w_imple_adv_ref;
    }

}
新建抽象工厂接口的普通车low工厂实现类：
package car_factory_imple;

import car_factory_interface.Icar_factory;
import car_imple.car_3w_imple_low;
import car_imple.car_audi_imple_low;
import car_interface.Icar_interface;

public class car_factory_low implements Icar_factory {

    public Icar_interface create_audi_car() {

        car_audi_imple_low car_audi_imple_low_ref = new car_audi_imple_low();
        car_audi_imple_low_ref.setName("奥迪A6");
        car_audi_imple_low_ref.setSpeed(300);

        return car_audi_imple_low_ref;
    }

    public Icar_interface create_threeW_car() {

        car_3w_imple_low car_3w_imple_low_ref = new car_3w_imple_low();
        car_3w_imple_low_ref.setName("大众A6");
        car_3w_imple_low_ref.setSpeed(300);

        return car_3w_imple_low_ref;
    }

}
    上面已经有抽象工厂和具体工厂的实现类了。
    新建汽车接口：
package car_interface;

public interface Icar_interface {

    public void start();

    public void stop();

}
    新建汽车父类：
package car_imple;

import car_interface.Icar_interface;

public class base_car_imple implements Icar_interface {

    private int speed;

    private String name;

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void start() {

    }

    public void stop() {

    }

}
新建大众高级车：
package car_imple;

import car_interface.Icar_interface;

public class car_3w_imple_adv extends base_car_imple {

    public void start() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术停车了");
    }

}
    新建大众普通车：
package car_imple;

import car_interface.Icar_interface;

public class car_3w_imple_low extends base_car_imple {

    public void start() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术停车了");
    }

}
    新建大众普通车：
package car_imple;

import car_interface.Icar_interface;

public class car_audi_imple_adv extends base_car_imple {

    public void start() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("富华版：" + this.getName() + " 车以专利技术停车了");
    }

}
新建奥迪普通车：
package car_imple;

import car_interface.Icar_interface;

public class car_audi_imple_low extends base_car_imple {

    public void start() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术起动了　最高速度为："
                + this.getSpeed());
    }

    public void stop() {
        System.out.println("普通版：" + this.getName() + " 车以专利技术停车了");
    }

}
    新建客户端运行类：
package run_main;

import car_factory_imple.car_factory_adv;
import car_factory_interface.Icar_factory;
import car_interface.Icar_interface;

public class run_main {

    public static void main(String[] args) {

        Icar_factory Icar_factory_ref = new car_factory_adv();

        Icar_interface Icar_interface_ref = Icar_factory_ref
                .create_threeW_car();
        Icar_interface_ref.start();
        Icar_interface_ref.stop();


    }
}
    程序运行结果如下：
富华版：大众A6 车以专利技术起动了　最高速度为：300
富华版：大众A6 车以专利技术停车了
    抓一篇阎宏的小文字：
一开始只在后花园中种蔬菜类的时候可以用简单工厂模式，由工厂负责生成具体的蔬菜类，

但是如果后花园要引进水果类的时候简单模式就行不通了，因此需要使用工厂方法模式，将产品类族分开。

但是如果后花园的规模继续扩大到地域范围的分割时，比如说一个在北京，一个在上海的时候，工厂方法模式就不够了，因为对两个后花园来说，每个后花园的植物是要被种在一起的，并且两个后花园用工厂方法模式是无法体现其区别的
    从程序中可以看到，工厂是抽象的，工厂的实现是不样的，不同的工厂创建出不同汽车。而工厂方法仅仅是用一个工厂去创建很多汽车。