设计模式之工厂模式（二）

由于这个只是用来做笔记，查了一些网上的资料，发现大致意思明白，但好多并没有说的十分清晰，自己这里也是自己的理解，不一定对，仅供自己看看！
都是把创建对象的过程封装起来！
主要有三种：简单工厂、工厂方法、抽象工厂；
简单工厂：就是独立出去一个工厂类来封装对象的创建，里面直接生产出产品（可以是同一个产品的不同系列：车:运动型，普通型等）（实例对象）
工厂方法：主要针对一个产品；定义一个抽象的类或接口，包含创建产品的方法，让子类去实现方法决定实例化哪一个对象。其中产品也是继承（可以是一个类型的产品也可以是多个类型，但属于同一个类：比如：汽车:运动型、普通型的都属于同一个产品）。
工厂方法主要是在方法，这个方法可以放在别的类中，比如4S店、某个省的汽车生产分公司。
下面看一个宝马和奥迪的生产汽车的例子：
汽车类：一个抽象的接口汽车 两个实现类 运动型汽车和普通型汽车

public interface Car {
    void getCarName(String name);
}

public class AudiCar implements Car {

    @Override
    public void getCarName(String name) {
        // TODO Auto-generated method stub
        System.out.println("生产出Audi车！型号为:"+name);
    }

}

public class BMWCar implements Car {

    @Override
    public void getCarName(String name) {
        // TODO Auto-generated method stub
        System.out.println("生产出BMW车！型号为："+name);
    }

}

工厂方法接口 包含造车的抽象方法

public interface FactoryMethod {
    Car createCar();
}

奥迪和宝马实现工厂来生产不同品牌汽车

public class AudiFactoryMethod implements FactoryMethod {

    @Override
    public Car createCar() {
        // TODO Auto-generated method stub
        return new AudiCar();
    }

}

public class BMWFactoryMethod implements FactoryMethod {

    @Override
    public Car createCar() {
        // TODO Auto-generated method stub
        return new BMWCar();
    }

}

测试：

public class FactoryMethodDemo {
    public static void main(String[] args) {
        //每个厂商有自己的工厂造车，造成工艺可以不一样 只是针对一种产品
        FactoryMethod audiFactory=new AudiFactoryMethod();
        audiFactory.createCar().getCarName("普通型");
        audiFactory.createCar().getCarName("运动型");
        FactoryMethod bmwFactory=new BMWFactoryMethod();
        bmwFactory.createCar().getCarName("普通型");
        bmwFactory.createCar().getCarName("运动型");
    }
}

结果：
生产出Audi车！型号为:普通型
生产出Audi车！型号为:运动型
生产出BMW车！型号为：普通型
生产出BMW车！型号为：运动型
工厂方法主要是同一个产品等级结构，准确点来说：产品都继承自同一个超类（比如运动型和普通型汽车都是继承自同一个接口）。
好处就是：如果想生产一个城市型系列的汽车，那么奥迪公司就会在继承Car生产一个CityCar生产线，然后由再在工厂方法中根据参数生产城市车型。如果奥迪和宝马也都生产自行车，就必须要另创建一个工厂接口，然后奥迪和宝马都去再继承创建一个工厂，这样工厂每个厂商要创建多个工厂。
抽象工厂： 提供一个接口，用于创建一组相关的或依赖的对象的家族，而不需要明确指定具体类。针对是一组产品！（可以是汽车对应的：*、发动机、车体等产品）
宝马和奥迪公司也都生产自行车，不想建那么多工厂，所以一开始就是工厂同时生产汽车和自行车：
上面汽车类+下面的自行车类
自行车接口、奥迪自行车、宝马自行车

public interface Bike {
    public void getName();
}

public class AudiBike implements Bike {

    @Override
    public void getName() {
        // TODO Auto-generated method stub
        System.out.println("生产出AudiBike");
    }

}

public class BMWBike implements Bike {

    @Override
    public void getName() {
        // TODO Auto-generated method stub
        System.out.println("生产出BMWBike");
    }

}

抽象工厂类：这里面同时包含了汽车和自行车创造方法

public interface AbstractFactory {
    Car createCar();
    Bike createBike();
}

继承抽象类的宝马和奥迪汽车制造商

public class AudiFactory implements AbstractFactory {

    @Override
    public Car createCar() {
        // TODO Auto-generated method stub
        return new AudiCar();
    }

    @Override
    public Bike createBike() {
        // TODO Auto-generated method stub
        return new AudiBike();
    }

}

public class BMWFactory implements AbstractFactory {

    @Override
    public Car createCar() {
        // TODO Auto-generated method stub
        return new BMWCar();
    }

    @Override
    public Bike createBike() {
        // TODO Auto-generated method stub
        return new BMWBike();
    }

}

测试：

public class FactoryDemo {
    public static void main(String[] args) {
        AbstractFactory audiFactory=new AudiFactory();
        audiFactory.createCar().getCarName("运动型");
        audiFactory.createBike().getName();
        AbstractFactory bmwFactory=new BMWFactory();
        bmwFactory.createCar().getCarName("运动型");
        bmwFactory.createBike().getName();
    }
}

运行结果：
生产出Audi车！型号为:运动型
生产出AudiBike
生产出BMW车！型号为：运动型
生产出BMWBike
抽象工厂模式：同样提供接口让子类去实例化，但它给子类提供多种相关产品的实例化方法，生产不同产品供用户选择，这里是出现多个产品（继承多个接口或抽象类），优点是可以创建比较少的工厂。但是如果想增加一个产品（产品接口），那修改就需要从抽象工厂到具体实现类都要修改。
工厂方法模式与抽象工厂模式的比较：
工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。产品就是这里的汽车，而等级结构就是比如：运动型汽车、普通型汽车、城市型汽车等，产品自行车：山地自行车、公路自行车等。
它们之间可以试用不同的情况：如果只生产一种商品，但是会衍生出很多品种或系列。那可以使用工厂方法，添加也比较简单，产品继承接口实现，工厂添加生产线（创建该对象）；它的缺点就是：如果想生产另一个产品，则需要创建一整套和现在相同的体系（产品接口及实现、工厂接口及实现）
如果是生产多种商品和等级结构，可以使用抽象的工厂方法，可以减少工厂的数量。但是如果想增加一个产品比如这里生产摩托车就会变得复杂，从上到下工厂都要修改（所有继承抽象的工厂，因为抽象类中Moto createMoto（）需要实现），但是如果是奔驰也想生产，那么就很容易生产，只需要抽象继承接口工厂，实现自己的汽车。
所以使用工厂方法是：这些生产出来的产品属于同一个等级结构：这里等级结构根据实际情况不同而不同：主要区别还是看产品接口数量。由于抽象工厂模式里面的产品是不容易改变的，所以可以是某一个产品的具体原料家族，比如：汽车轮胎、车体、发动机等，用户根据自己的选择来提取想要的产品同时组装。