工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

工厂模式分为：

• 简单工厂模式
• 工厂方法模式
• 抽象工厂模式

简单工厂模式：

首先常见一个Car接口，接口中定义一个run()方法：

package top.bigking.factory.simpleFactory;

/**
 * @Author ABKing
 * @Date 2020/2/7 下午3:43
 **/
public interface Car {
    public void run();
}

再写两个类实现这个Car接口

package top.bigking.factory.simpleFactory;

/**
 * @Author ABKing
 * @Date 2020/2/7 下午3:44
 **/
public class Benchi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰");
    }
}

package top.bigking.factory.simpleFactory;

/**
 * @Author ABKing
 * @Date 2020/2/7 下午3:44
 **/
public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪");
    }
}

测试如下：

/**
 * @Author ABKing
 * @Date 2020/2/7 下午3:45
 **/
public class TestSimpleFactory {
    @Test
    public void testNoFactory(){
        Car car1 = new Benchi();
        Car car2 = new Byd();
        car1.run();
        car2.run();


    }
}

很明显我们可以看到，作为用户来讲，必须知道接口，还要知道实现类。

而我们不希望用户知道这么多，我们需要隐藏这些，由此，我们引入了简单工厂模式：

新建一个工厂类：

package top.bigking.factory.simpleFactory;

/**
 * @Author ABKing
 * @Date 2020/2/7 下午3:48
 **/
public class CarFactory {
    public Car getCar(String carName){
        if(carName.equals("奔驰")){
            return new Benchi();
        }
        else if(carName.equals("比亚迪")){
            return new Byd();
        }
        return null;
    }
}

进行测试：

package top.bigking.factory.simpleFactory;

import org.junit.Test;
import sun.security.krb5.internal.ccache.CCacheInputStream;

/**
 * @Author ABKing
 * @Date 2020/2/7 下午3:45
 **/
public class TestSimpleFactory {
    @Test
    public void testNoFactory(){
        Car car1 = new Benchi();
        Car car2 = new Byd();
        car1.run();
        car2.run();
    }
    @Test
    public void testCarFactory(){
        CarFactory carFactory = new CarFactory();
        Car car1 = carFactory.getCar("比亚迪");
        Car car2 = carFactory.getCar("奔驰");
        car1.run();
        car2.run();
    }
}

这样用户就不必知道具体的实现了，只需要知道相应的接口即可。

但是我们应该注意的是：如果我们需要增加新的车，比如兰博基尼，我们就需要添加一个新的类，并且在修改工厂类

这显然违反了 开闭原则（对扩展开放，对修改关闭）。

所以我们引入了新的工厂模式：

工厂方法模式

把工厂中的方法抽象出来，形成新的类，BenchiFactory和BydFactory

同时，由于这两个类具有相同的抽象意义，我们定义一个接口，CarFactory

package top.bigking.factory.factoryMethod;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午5:28
 **/
public interface CarFactory {
    public Car getCar();
}

package top.bigking.factory.factoryMethod;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午5:25
 **/
public class BenchiFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Benchi();
    }
}

package top.bigking.factory.factoryMethod;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午5:24
 **/
public class BydFactory implements CarFactory{
    @Override
    public Car getCar() {
        return new Byd();
    }
}

编写JUnit测试

package top.bigking.factory.factoryMethod;

import org.junit.Test;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午5:27
 **/
public class TestFactoryMethod {
    @Test
    public void testFactoryMethod(){
        Car car1 = new BenchiFactory().getCar();
        Car car2 = new BydFactory().getCar();
        car1.run();
        car2.run();
    }
}

工厂方法模式的优点是不需要修改已有的代码，满足开闭原则（对扩展开放，对修改关闭）,但是缺点是会增加大量的类，对维护增加了难度。

另外还有一种工厂模式：抽象工厂模式

抽象工厂模式是用来增加产品族的，对增加单个产品无能为力

定义引擎的接口及其实现：

package top.bigking.factory.abstractFactory;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午10:23
 **/
public interface Engine {
    public void start();
    public void run();
}
class GoodEngine implements Engine{

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

    @Override
    public void run() {
        System.out.println("好发动机运行");
    }
}
class BadEngine implements Engine{

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

    @Override
    public void run() {
        System.out.println("差发动机运行");
    }
}

定义轮胎的接口及其实现

package top.bigking.factory.abstractFactory;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午10:25
 **/
public interface Tyre {
    public void roll();
}
class GoodTyre implements Tyre{
    @Override
    public void roll() {
        System.out.println("好轮胎滚动");
    }
}
class BadTyre implements Tyre{
    @Override
    public void roll() {
        System.out.println("差轮胎滚动");
    }
}

定义工厂接口

package top.bigking.factory.abstractFactory;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午5:28
 **/
public interface CarFactory {
    public Engine getEngine();
    public Tyre getTyre();
}

写工厂的两个实现，好车和差车

package top.bigking.factory.abstractFactory;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午10:10
 **/
public class GoodCarFactory implements CarFactory {

    @Override
    public Engine getEngine() {
        return new GoodEngine();
    }

    @Override
    public Tyre getTyre() {
        return new GoodTyre();
    }
}

package top.bigking.factory.abstractFactory;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午10:32
 **/
public class BadCarFactory implements CarFactory {
    @Override
    public Engine getEngine() {
        return new BadEngine();
    }

    @Override
    public Tyre getTyre() {
        return new BadTyre();
    }
}

测试代码：

package top.bigking.factory.abstractFactory;

import org.junit.Test;

/**
 * @Author ABKing
 * @Date 2020/2/10 下午10:34
 **/
public class TestAbstractFactory {
    //测试好车
    @Test
    public void testGoodCarFactory(){
        CarFactory carFactory = new GoodCarFactory();
        Engine engine = carFactory.getEngine();
        Tyre tyre = carFactory.getTyre();
        engine.start();
        engine.run();
        tyre.roll();
    }
    //测试差车
    @Test
    public void testBadCarFactory(){
        CarFactory carFactory = new BadCarFactory();
        Engine engine = carFactory.getEngine();
        Tyre tyre = carFactory.getTyre();
        engine.start();
        engine.run();
        tyre.roll();
    }

}