再看设计模式--工厂模式

        之前就有读过《headfirst设计模式》一书，就像往常一样，读完了就读完了，就没然后了。为了造飞机，现在必须开始重新读取了，就从最常出现的工厂模式开始吧。

        首先，工厂模式分为工厂方法和抽象工厂两种。工厂方法通过提供一个接口（方法），让子类去决定生产哪一种具体的产品，而抽象工厂则是在这个基础之上，达到生产多种具体的产品。

        首先瞅瞅工厂方法模式，本人工厂方法所用到的类图：

        首先，抽象出产品：

/**
 * 抽象的产品
 */
public abstract class Car {

    protected Integer price;
    protected String name;
    protected String country;

    public Car() {
    }

    public Car(String name, Integer price) {
        this.price = price;
        this.name = name;
    }

    //省略getset
}

        将产品进行分类，分为国产和进口，不过这一步也可以省略的·····

/**
 * 其实这个类可以省略，不过想分国产和进口车，
 * 故而把这个类设为abstract，而具体的产品还是
 * 继承该类的子类。
 */
public abstract class ChinaCar extends Car {

    public ChinaCar() {
    }

    public ChinaCar(String name, Integer price) {
        super(name, price);
        this.country = "国产";
    }
}

        接下来，是真正被成产出来的产品：

/**
 * 具体的汽车产品
 */
public class SpeedChinaCar extends ChinaCar {

    private Integer speed;

    public SpeedChinaCar() {
    }

    public SpeedChinaCar(String name, Integer price, Integer speed) {
        super(name, price);
        this.speed = speed;
    }

    public Integer getSpeed() {
        return speed;
    }

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

        定义一个抽象类的工厂，生产的任务由于种类繁多而导致本部工厂干脆停止生产，所以定义为抽象方法，交给下面的具体工厂去实现：

/**
 * 工厂抽象类
 */
public abstract class CarFactory {

    //核心生产方法
    public abstract Car createCar(String type);

    public void orderCar(String type) {
        Car car = createCar(type);
        System.out.println("我是"+car.getCountry()+" "+car.getName() + ",价值：" + car.getPrice() + "元钱。。。。");
    }
}

        真正进行生产的工厂：

/**
 * 国产车工厂生产真正具体的产品
 */
public class ChinaCarFactory extends CarFactory {
    @Override
    public Car createCar(String type) {
        //通过提供的type确定要生产国产车的那种具体类型的车
        if (type.equals("speed"))
            return new SpeedChinaCar("红旗", 30, 250);
        else if (type.equals("SUV"))
            return new SUVChinaCar("荣威", 500, 250);
        else
            return null;

    }
}

        找到4s店，并认识一下：

public class CarStore {

    private CarFactory carFactory;


    public void showCar(String type) {
        getCarFactory().orderCar(type);
    }

    public CarFactory getCarFactory() {
        return carFactory;
    }

    public void setCarFactory(CarFactory carFactory) {
        this.carFactory = carFactory;
    }


}

        让4s店先搞个现车出来瞅瞅：

  public static void main(String args[]) {

        //找到4s
        CarStore carStore=new CarStore();
        //确定要哪国车就联系哪个国家的工厂
        carStore.setCarFactory(new GermanyCarFactory());
        //确定汽车类型，展示订车信息
        carStore.showCar("speed");

        //德国车太贵，还是看看国产
        carStore.setCarFactory(new ChinaCarFactory());
        //看看跑车
        carStore.showCar("speed");
        //再看看SUV
        carStore.showCar("SUV");
    }
}

结果：

        所以，工厂方法就是将生产的任务交给子类去实现，因为产品的种类繁多。如果直接以具体（本部）工厂生产这种方式进行生产，随着具体产品种类的不断增多，将会给本部工厂造成巨大的压力，将会造成代码无限的拉长。因此，引入工厂方法，可以将生产任务转交给子工厂，可以避免本部的生产压力，同时还可以不断的扩张，从而达到了 解耦 的目的。

        so，这就是工厂方法。

/**
 * 简单工厂模式即只让本部进行生产，一种规范，不是设计模式
 */
public class Factory {
    public Car String(String type) {
        Car car = null;
        if (type.equals("GermanySpeed")) {
            car = new SpeedGermanyCar();
            return car;
        } else if (type.equals("GermanySUV")) {
            car = new SUVGermanyCar();
            return car;
        } else if (type.equals("ChinaSpeed")) {
            car = new SpeedChinaCar();
            return car;
        } else if (type.equals("ChinaSUV")) {
            car = new SUVChinaCar();
            return car;
        } else
            return null;
    }
}