设计模式之工厂模式

工厂模式是java中常用的设计模式之一。它属于创建型设计模式；
创建型设计模式主要关注的是对象的创建过程，将对象的创建进行封装、抽象，客户端不需关心对象如何创建即可使用，有效的进行了业务解耦以及隔离。它主要分为：
    1：单例模式；
    2：简单工厂模式；
    3：工厂方法模式；
    4：抽象工厂模式；
    5：建造者模式；
    6：原型模式；
本文介绍2，3，4三个设计模式；

简单工厂设计模式
概念：简单工厂设计模式就相当于定义一个创建对象的统一入口，这样以来客户端只需要告诉工厂要创建什么类型的实例即可；
 案例介绍：在很久以前人们生活中还没有汽车工厂时，若想得到一个汽车，那么每家每户都会去造车。如果有一天车子中某个零件的使用方式变化了，那么这时候每家每户都要去按照原先造车时放的零件给替换，由于每家车子按照方法也不同，导致维修也十分的困难。这样的持续发展，社会中就衍生出汽车工厂这一概念，统一了标准。
角色组成：抽象产品；具体产品；具体工厂；
代码演示：

抽象产品：

/**
 * 抽象产品角色-汽车
 *
 * @author zx
 **/
public abstract class Car {

    private String name;
    //....等等属性

    public abstract void drive();

    public String getName() {
        return name;
    }

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

具体产品：

/**
 * 具体产品角色-宝马车
 *
 * @author zx
 **/
public class Bwm extends Car {

    @Override
    public void drive() {
        System.out.println("bwm car driving");
    }
}

/**
 * 具体产品角色-奔驰车
 *
 * @author zx
 **/
public class BanZ extends Car {

    @Override
    public void drive() {
        System.out.println("BanZ car driving");
    }
}

工厂：

/**
 * 汽车简单工厂
 *
 * @author zx
 **/
public class CarFactory {

    public static Car createCar(String type) {
        if (type == null || "".equals(type)) {
            return null;
        }
        Car car = null;
        switch (type) {
            case "BWM":
                car = new Bwm();
                car.setName("BWM");
                break;
            case "BenZ":
                car = new BanZ();
                car.setName("BeanZ");
                break;
            default:
                break;
        }
        return car;
    }
}

工厂客户端：

/**
 * 工厂客户端
 *
 * @author zx
 **/
public class Client {

    class Client1 {
        public void doSomething() {
            // 没有工厂时
            Car bwm1 = new Bwm();
            bwm1.setName("BWM"); // 如果这个时候由于业务需要把BWM改成宝马，把BanZ改成奔驰。自行对比对于系统的影响面
            bwm1.drive();

            // 有工厂
            Car bwm = CarFactory.createCar("BWM");
            bwm.drive();
        }
    }

    class Client2 {
        public void doSomething() {
            // 没有工厂时
            Car banZ1 = new BanZ();
            banZ1.setName("BanZ"); // 如果这个时候由于业务需要把BWM改成宝马，把BanZ改成奔驰。自行对比对于系统的影响面
            banZ1.drive();

            // 有工厂
            Car banZ = CarFactory.createCar("BanZ");
            banZ.drive();
        }
    }
}

工厂方法设计模式

概念：工厂方法设计模式是对简单工厂设计模式的一种升华。原先是大工厂，现在可以根据面向对象抽象出某一类具有相同特性的工厂；由于简单工厂设计模式其实是违背了设计模式原则中的开闭原则。
案例介绍：沿用上一个案例，由于汽车品牌越来越多，同时也伴随着统一品牌下的车系种类越来越多，这个时候一个工厂中需要干的事情非常的多，越来越不专业；
角色组成：抽象产品；具体产品；抽象工厂；具体工厂；
代码演示：

抽象产品：

/**
 * 抽象产品-汽车
 *
 * @author zx
 **/
public abstract class Car {

    private String name;
    // ...

    public abstract void drive();

    public String getName() {
        return name;
    }

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

具体产品：

/**
 * 具体产品-宝马车
 *
 * @author zx
 **/
public class Bwm extends Car {

    @Override
    public void drive() {
        System.out.println("bwm car driving");
    }
}

/**
 * 具体产品-奔驰车
 *
 * @author zx
 **/
public class BanZ extends Car {

    @Override
    public void drive() {
        System.out.println("banz car driving");
    }
}

抽象工厂：

/**
 * 工厂抽象角色
 *
 * @author zx
 **/
public interface CarFactory {

    public Car createCar();
}

具体工厂：

/**
 * 具体抽象工厂角色-宝马工厂
 *
 * @author zx
 **/
public class BwmFactory implements CarFactory {

    @Override
    public Car createCar() {
        Bwm bwm = new Bwm();
        bwm.setName("BWM");
        return bwm;
    }
}

/**
 * 具体抽象工厂角色-奔驰工厂
 *
 * @author zx
 **/
public class BanZFactory implements CarFactory {

    @Override
    public Car createCar() {
        BanZ banZ = new BanZ();
        banZ.setName("BanZ");
        return banZ;
    }
}

工厂客户端：

/**
 * 客户端
 *
 * @author zx
 **/
public class Client {

    class Client1 {
        public void doSomething() {
            CarFactory factory = new BwmFactory();
            factory.createCar().drive();
        }
    }

    class Client2 {
        public void doSomething() {
            CarFactory factory = new BanZFactory();
            factory.createCar().drive();
        }
    }
}

抽象工厂设计模式
概念：抽象工厂设计模式类似工厂方法，当抽象工厂产品族只有一个产品时就成为了工厂方法，也可以理解为工厂方法的升级版。抽象工厂主要是用于创建一个产品族。
案例介绍：现在有BWM工厂，但是现在BWM中各个系列中比如：引擎，轮毂等；那么BWM工厂需要生产出各个系列车子的不同产品。
角色组成：多个抽象产品、多个具体产品、抽象工厂、具体工厂。
代码演示：

抽象产品：

/**
 * 抽象产品--轮毂
 *
 * @author zx
 **/
public abstract class BwmWheel {

    private String name;

    public abstract void useWheel();
}

/**
 * 抽象产品--引擎
 *
 * @author zx
 **/
public abstract class BwmEngine {

    private String name;

    public abstract void use();
}

具体产品：

/**
 * 具体产品--宝马320轮毂
 *
 * @author zx
 **/
public class Bwm320Wheel extends BwmWheel {

    @Override
    public void useWheel() {
        System.out.println("i am using bwm320 wheel");
    }
}

/**
 * 具体产品--宝马520轮毂
 *
 * @author zx
 **/
public class Bwm520Wheel extends BwmWheel {

    @Override
    public void useWheel() {
        System.out.println("i am using bwm520 wheel");
    }
}

/**
 * 具体产品--宝马320引擎
 *
 * @author zx
 **/
public class Bwm320Engine extends BwmEngine {

    @Override
    public void use() {
        System.out.println("i am using bwm320 engine");
    }
}

/**
 * 具体产品--宝马520
 *
 * @author zx
 **/
public class Bwm520Engine extends BwmEngine {

    @Override
    public void use() {
        System.out.println("i am using bwm520 engine");
    }
}

抽象工厂：

/**
 * 抽象工厂--宝马工厂
 *
 * @author zx
 **/
public interface BwmFactory {

    public BwmEngine createEngine();

    public BwmWheel createWheel();
}

具体工厂：

/**
 * 具体工厂--宝马320工厂
 *
 * @author zx
 **/
public class Bwm320Factory implements BwmFactory {
    @Override
    public BwmEngine createEngine() {
        return new Bwm320Engine();
    }

    @Override
    public BwmWheel createWheel() {
        return new Bwm320Wheel();
    }
}

/**
 * 具体工厂--520
 *
 * @author zx
 **/
public class Bwm520Factory implements BwmFactory {
    @Override
    public BwmEngine createEngine() {
        return new Bwm520Engine();
    }

    @Override
    public BwmWheel createWheel() {
        return new Bwm520Wheel();
    }
}

工厂客户端：

/**
 * 客户端
 *
 * @author zx
 **/
public class Client {

    class Client1 {
        public void doSomething() {
            BwmFactory factory = new Bwm320Factory();
            factory.createEngine().use();
            factory.createWheel().useWheel();
        }
    }

    class Client2 {
        public void doSomething() {
            Bwm520Factory factory = new Bwm520Factory();
            factory.createEngine().use();
            factory.createWheel().useWheel();
        }
    }
}

总结：抽象工厂和工厂方法最主要的区别就是产品。工厂方法只有一个产品，而抽象工厂是一个产品族；自然而然对应的工厂也就不同，工厂方法只能创建一个产品，抽象工厂需要创建的是一个产品族。在设计程序时，不要过多在意与是抽象工厂还是工厂方法，在程序使用工厂时，注重的是为了程序能够更好的解耦，往往也不会单独的工厂模式出现，会存在多种设计模式组合而成。