第四式 工厂模式

工厂模式

一 简单工厂

　　我们去4s店里面买车下订单，然后汽车工厂根据我们的订单来生成对应的车辆。

public class CarShop {
    public Car order(String type){
        Car car = null;
        if("Benz".equals(type)){
            car = new BenzCar();
        }else if("Tyota".equals(type)){
            car = new ToytaCar();
        }else{
            return car;
        }
        car.design();
        car.assemble();
        car.test();
        return car;
    }
}

这样的代码实现，会随着车辆种类的变多变成if else 地狱，后期对车型的维护会变得无比艰难，所有需要创建Car类的地方都要维护到。我们试着将代码中会变化的部分抽离出来并封装：

public class SimpleCarFactory {
    public Car createCar(String type){
        Car car = null;
        if("Benz".equals(type)){
            car = new BenzCar();
        }else if("Tyota".equals(type)){
            car = new ToytaCar();
        }else{
            return car;
        }
        return car;
    }
}
public class CarShop {
    SimpleCarFactory simpleCarFactory;

    public CarShop(SimpleCarFactory simpleCarFactory){
        this.simpleCarFactory = simpleCarFactory;
    }

    public Car order(String type){
        Car car = simpleCarFactory.createCar(type);
        car.design();
        car.assemble();
        car.test();
        return car;
    }
}

这样分离之后，虽然if else地狱依然存在，但是在别的需要创建Car对象的地方就不用重复维护了。
简单工厂模式与其说是一种设计模式，不如说是一种编程习惯。类图如下：

　　

二 工厂模式

　　当我们的汽车销售形成规模，在各地都需要4s店，而各地对汽车的审美都有自己的要求，即需要一些地方化的服务。我们之前一刀切式地在order方法中根据车型来创建

　　汽车对象的方式需要进行调整了，因为它不能满足需求了。代码调整如下：

　　1.将CarShop类中createCar方法抽象出来，让各地的分店自行实现自己的。

public abstract class CarShop {
    public Car order(String type){
        Car car = createCar(type);
        car.design();
        car.assemble();
        car.test();
        return car;
    }

    public abstract Car createCar(String type);
}

　　2.北京和大连的4s店

public class BeijingCarShop extends CarShop {
    public Car createCar(String type) {
        Car car = null;
        if("Benz".equals(type)){
            car = new BeijingBenzCar();
        }else if("Tyota".equals(type)){
            car = new BeijingTyotaCar();
        }else{
            return car;
        }
        return car;

    }
}
public class DalianCarShop extends CarShop {
    public Car createCar(String type) {
        Car car = null;
        if("Benz".equals(type)){
            car = new DalianBenzCar();
        }else if("Tyota".equals(type)){
            car = new DalianTyotaCar();
        }else{
            return car;
        }
        return car;

    }
}

　　工厂方法用来处理对象的创建，并将这样的行为封装在子类中。这样程序中超类的代码和子类对象的创建代码就解耦了。

　　

　　

 　　工厂方法模式：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

　　设计原则：依赖倒置原则--要依赖抽象，不要依赖具体类。

三 抽象工厂模式

 　　当我们的需求变更为为不同的品牌的车生产不同配置的车时，也就是说同样车型的车，有了不同的配置。配置大概抽出几个，如轮胎，引擎，座椅等。

　　面向接口设计原则，我们将这些个配置也全都抽象出来，这样上面的工厂模式就不适合了。我们来看看抽象工厂模式。

　　抽象工厂模式：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

　　类图如下：

　　

　　代码实现：

　　1.配件接口，及高低端配件的实现类

　

//引擎

public interface Engine {
    public void run();
    public void start();
}

class LuxuryEngine implements Engine{

    public void run() {
        System.out.println("跑得快");
    }

    public void start() {
        System.out.println("启动快");
    }
}

class LowEngine implements Engine{

    public void run() {
        System.out.println("跑得慢");
    }

    public void start() {
        System.out.println("启动慢");
    }
}
//轮胎
public interface Tyre {
    public void revolve();
}

class LuxuryTyre implements Tyre{

    public void revolve() {
        System.out.println("耐磨");
    }
}

class LowTyre implements Tyre{

    public void revolve() {
        System.out.println("不耐磨");
    }
}
//座椅
public interface Seat {
    public void message();
}

class LuxurySeat implements Seat{

    public void message() {
        System.out.println("真皮沙发");
    }
}

class LowSeat implements Seat{

    public void message() {
        System.out.println("塑料沙发");
    }
}

　　2.抽象工厂类

public interface CarFactory {
    Engine createEngine();
    Tyre createTyre();
    Seat createSeat();
}

　　3.高低端工厂实现类

public class LowCarFactory implements CarFactory {
    public Engine createEngine() {
        return new LowEngine();
    }

    public Tyre createTyre() {
        return new LowTyre();
    }

    public Seat createSeat() {
        return new LowSeat();
    }
}
public class LuxuryCarFactory implements CarFactory {
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    public Tyre createTyre() {
        return new LuxuryTyre();
    }

    public Seat createSeat() {
        return new LuxurySeat();
    }
}

　　4.测试

public class Client {
    public static void main(String[] args){
        CarFactory factory = new LowCarFactory();
        Engine e = factory.createEngine();
        e.start();
        e.run();
    }
}

　　运行结果：

　　

 四 总结

　　要点：

　　简单工厂模式：虽然某种程度不符合设计原则，但实际使用最多

　　工厂方法模式：不修改已有类的前提下，通过增加新的工厂类实现扩展

　　抽象工厂模式：不可以增加产品，但可以增加产品族

　　应用场景：

　　JDK中Calendar的getInstance方法

　　JDBC中Connection对象的获取

　　Spring中IOC容器创建管理bean对象

　　反射中Class对象的newInstance()