Java工厂模式

1.工厂模式的介绍

工厂方法模式（英语：Factory method pattern）是一种实现了“工厂”概念的面向对象设计模式。就像其他创建型模式一样，它也是处理在不指定对象具体类型的情况下创建对象的问题。工厂方法模式的实质是“定义一个创建对象的接口，但让实现这个接口的类来决定实例化哪个类。工厂方法让类的实例化推迟到子类中进行。在面向对象程序设计中，工厂通常是一个用来创建其他对象的对象。工厂是构造方法的抽象，用来实现不同的分配方案。

2.简单工厂模式（静态工厂）

1. 先看一下没有使用任何设计模式的情况下的代码。这里写了一个Car接口和两个实现接口的类Audi和Byd，还有一个测试类Demo01。

package factory;

public interface Car {
    void run();
}

package factory;

public class Audi implements Car{
    @Override
    public void run() {
        System.out.println("奥迪在跑....");
    }
}

package factory;

public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪在跑.....");
    }
}

package factory;

/**
 1. 普通模式下的测试
 */
public class Demo01 { 
    public static void main(String[] args) {
        Car c1 = new Audi();
        Car c2 = new Byd();

        c1.run();
        c2.run();
    }
}

下面是普通方法下的UML图。这时候我们发现调用者需要直接和这些类打交道。同时，当创建这些类本身是个非常复杂的事情的时候，会有大量重复代码。最重要的当这个类非常复杂时（例子写的很简单），调用者想创建这个类的对象时还需要了解这个类的很多，而调用者仅仅是想要创建一个对象而已。
2. 下面看一下使用简单工厂模式的代码，这里写了个CarFactory类和测试类Demo02。代码如下。

package factory;

/**
 * 简单工厂
 */
public class CarFactory {
	/*第一种造车方法*/
    public static Car createCar(String type) {
        if("奥迪".equals(type)) {
            return new Audi();
        }
        if("比亚迪".equals(type)) {
            return new Byd();
        } else {
            return null;
        }
    }

	/*第二种造车方法*/
    public static Car createAudi() {
        return new Audi();
    }

	/*第二种造车方法*/
    public static Car createByd() {
        return new Byd();
    }
}

package factory;

/**
 1. 简单工厂
 */
public class Demo02 {
    public static void main(String[] args) {
        //不必要管内部怎么实现 直接调用工厂方法 调用者不用直接和相关类打交道，和工厂打交道就行 这样具有更详细的分工。
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");
        Car c3 = CarFactory.createAudi();
        Car c4 = CarFactory.createByd();

        c1.run();
        c2.run();
        c3.run();
        c4.run();
    }
}

这时候的UML图如下。可以发现调用者不用理会类的内部怎么实现，也不用和他们打交道，直接和工厂打交道就行。从而达到了更加详细的分工。以上面的例子来说，调用者想创建奥迪车，直接问工厂要奥迪车就行，不需要知道具体怎么创建奥迪车（这个过程可能很复杂）。

2. 缺点：对于增加新类要修改代码，违背了OCP（开闭原则，一个软件的实体应当对扩展开放，对修改关闭）。

3.工厂方法模式

1. 有了上面的基础后，下面我们直接看工厂方法模式实现上面的需求的代码。其中定义了一个CarFactory接口，两个实现了这个接口的类AudiFactory和BydFactory，还有一个测试用的Demo类（前面重复的类就没有列出了）。

package factoryMethod;

public interface CarFactory {
    Car createCar();
}

package factoryMethod;

public class AudiFactory implements CarFactory{
    @Override
    public Car createCar() {
        return new Audi();
    }
}

package factoryMethod;

public class BydFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Byd();
    }
}

package factoryMethod;

public class Demo {
    //现在如果要增加一个新的类 比如奔驰 这样不用修改原来的代码 直接增加一个奔驰factory即可 符合开闭原则 但是类就多了
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();

        c1.run();
        c2.run();
    }
}

这时的UML图如下。可以发现创建了许多新类，同时调用者需要知道更多的信息，这便是工厂方法模式的缺点。但是工厂方法模式符合面向对象程设设计的开闭原则（一个软件的实体应当对扩展开放，对修改关闭），如当创建一个新的Car类Benz时，不用修改原来的代码，直接创建一个新类BenzFactory实现CarFactory接口即可。

3.抽象工厂模式

下面以汽车配件（发动机、座椅和轮胎）的模型分析抽象工厂模式。这里我们把汽车分为高端汽车配件和低端汽车配件，于是我们有Engine、Seat、Tyre和CarFactory接口，同时我们有实现CarFactory接口的类LuxuryCarFactory和lowFactory。最后写了个测试类Demo。代码如下。

package abstractFactory;

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

/*高端发动机*/
class LuxuryEngine implements Engine {
    @Override
    public void run() {
        System.out.println("高端发动机转的快！");
    }

    @Override
    public void start() {
        System.out.println("高端发动机启动快！");
    }
}

/*低端发动机*/
class LowEngine implements Engine {
    @Override
    public void run() {
        System.out.println("低端发动机转的慢！");
    }

    @Override
    public void start() {
        System.out.println("低端发动机启动慢！");
    }
}

package abstractFactory;

public interface Seat {
    void massage();
}

class LuxurySeat implements Seat {
    @Override
    public void massage() {
        System.out.println("高端座椅，可以按摩");
    }
}

class LowSeat implements Seat {
    @Override
    public void massage() {
        System.out.println("低端座椅，不可以按摩");
    }
}

package abstractFactory;

public interface Tyre {
    void revolve();
}

/*高端轮胎*/
class LuxuryTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("高端轮胎磨损慢");
    }
}

/*低端轮胎*/
class LowTyre implements Tyre {
    @Override
    public void revolve() {
        System.out.println("低端轮胎磨损快");
    }
}

package abstractFactory;

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

package abstractFactory;

public class LuxuryCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

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

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

package abstractFactory;

public class LowFactory implements CarFactory{
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

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

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }
}

package abstractFactory;

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

这时候我们发现抽象工厂模式可以弄出产品链。如示例中的高端汽车配件链和低端汽车配件链。

4.总结

1. 这篇是本人学习时记得笔记，如有错误的地方恳请大家指正。
2. 简单工厂模式虽然不符合开闭原则（一个软件的实体应当对扩展开放，对修改关闭），但是实际使用最多。
3. 根据设计模式理论我们应该使用工厂方法，但是实际往往不同（好像TCP/IP协议也是这样 ）。
4. 抽象工厂模式可以弄出产品链。