工厂模式还不懂？看这里！

什么是工厂模式？

工厂模式是创建型设计模式，它是方便我们更好地创建对象而设计的一种模式。通过工厂模式创建的的对象，不会向客户端暴露对象创建的逻辑，并且通过一个共同的接口指向创建的对象。

这次我们主要来介绍简单工厂模式和抽象工厂模式~

简单工厂模式

说明：简单工厂模式的实现就是通过我们创建一个工厂类，然后通过此工厂为我们生产创建对象，从而使用对象。

我们通过下面的栗子去理解简单工厂模式的使用：

首先我们创建一个车辆的接口，以便后面具体车辆的实现（如自行车、摩托车）

// 定义车辆的接口
public interface Vehicle {
    // 定义一个驾驶的接口方法
    void driver();
}

接着让自行车类和摩托车类都去实现车辆的的接口

自行车类：

// 自行车类实现车辆接口
public class Bicycle extends SimpleFactory implements Vehicle{
    @Override
    public void driver() {
        System.out.println("骑自行车！");
    }
}

摩托车类：

// 摩托车类实现车辆接口
public class Motorcycle extends SimpleFactory implements Vehicle{
    @Override
    public void driver() {
        System.out.println("骑摩托车！");
    }
}

而简单工厂模式的最主要的便是创建的对象的工厂，通过工厂我们才能实现生产各种对象，并对这些生产对象进行使用。

创建一个生产车辆的工厂：

// 定义一个工厂类，用于生产车的对象
public class SimpleFactory {

    // 定义一个生产车的方法
    public Vehicle getVehicle(String vehicle){
        if(vehicle.equalsIgnoreCase("bicycle")){
            return new Bicycle();
        }else if (vehicle.equalsIgnoreCase("motorcycle")){
            return new Motorcycle();
        }
        return null;
    }
}

这样我们的工厂就可以去使用了，通过这些工厂中的方法，我们便可以去实现对车辆对象的创建，而不是直接调用车辆的对象。这样利用一个工厂去替我们生产对象的方式也就是我们说的简单工厂模式。

调用工厂去生产对象：

public class Main {

    public static void main(String[] args) {
        // 创建一个简单工厂对象
        SimpleFactory simpleFactory = new SimpleFactory();
        // 通过工厂对象的方法生产需要的车辆(这里是自行车)
        Vehicle bicycle = simpleFactory.getVehicle("bicycle");
        // 调用工厂生产的车辆的对象的方法
        bicycle.driver();

        // 通过工厂对象的方法生产需要的车辆(这里是摩托车)
        Vehicle Motorcycle = simpleFactory.getVehicle("Motorcycle");
        // 调用工厂生产的车辆的对象的方法
        Motorcycle.driver();
    }
}

运行结果如下：

如此，我们并没有具体去使用车辆的对象(如下代码)，这样便可以暴露自己创建对象的逻辑实现对对象的创建。

public class Main {
    public static void main(String[] args) {
        // 这样使用具体的车辆去创建对象(不使用工厂模式):自行车对象
        Vehicle vehicle1  = new Bicycle();
        vehicle1.driver();

        // 这样使用具体的车辆去创建对象(不使用工厂模式):摩托车对象
        Vehicle vehicle2  = new Motorcycle();
        vehicle2.driver();
    }
}

抽象工厂模式

说明：抽象工厂模式实现方法简单来说就是用一个超级工厂去创建多个工厂。我们使用这个超级工厂去创建工厂对象，然后用我们创建的工厂为我们创建对象。

分析：我们知道一个工厂不能既生产水果，又生产车辆，所以这时候就需要使用抽象工厂的设计模式，通过一个超级工厂去生产一个水果厂和车辆厂，然后通过车辆厂生产车辆，通过水果厂生产水果。

继续通过实例来了解抽象工厂模式：

首先我们创建两个接口：Vehicle和Fruit

// 定义车辆的接口
public interface Vehicle {
    // 定义一个驾驶的接口方法
    void driver();
}

// 定义一个水果的接口
public interface Fruit {
    // 定义吃的接口方法
    void eat();
}

然后对分别对这两个接口进行实现：

实现Vehicle的类分别为：Bicycle和Motorcycle

// 摩托车类实现车辆接口
public class Motorcycle implements Vehicle {
    @Override
    public void driver() {
        System.out.println("骑摩托车！");
    }
}

// 自行车类实现车辆接口
public class Bicycle implements Vehicle {
    @Override
    public void driver() {
        System.out.println("骑自行车！");
    }
}

实现Fruit接口的类分别为：Apple和Banana

// 实现Fruit的接口: Banana
public class Banana implements Fruit{
    @Override
    public void eat() {
        System.out.println("吃香蕉！");
    }
}

// 实现Fruit的接口: Apple
public class Apple implements Fruit{
    @Override
    public void eat() {
        System.out.println("吃苹果！");
    }
}

紧接着也就是最主要的就是通过一个抽象类来获取得到我们普通的工厂（水果厂和车辆厂）：

// 定义一个抽象工厂类
public abstract class AbstractFactory{
    abstract Vehicle getVehicle(String vehicle);
    abstract Fruit getFruit(String fruit);
}

通过继承该抽象类来实现分别实现生产水果的工厂FruitFactory和生产车辆的VehicleFactory：

// 定义一个水果工厂并继承抽象工厂AbstractFactory
public class FruitFactory extends AbstractFactory{
    @Override
    Vehicle getVehicle(String vehicle) {
        return null;
    }

    @Override
    Fruit getFruit(String fruit) {
        if(fruit.equalsIgnoreCase("apple")){
            return new Apple();
        }else if(fruit.equalsIgnoreCase("banana")){
            return new Banana();
        }
        return null;
    }
}

// 定义一个生产车辆的工厂并继承抽象工厂
public class VehicleFactory extends AbstractFactory{
    @Override
    Vehicle getVehicle(String vehicle) {
        if(vehicle.equalsIgnoreCase("bicycle")){
            return new Bicycle();
        }else if (vehicle.equalsIgnoreCase("motorcycle")){
            return new Motorcycle();
        }
        return null;
    }

    @Override
    Fruit getFruit(String fruit) {
        return null;
    }
}

这样我们就把创建了普通的两个工厂，我们需要创建一个生产普通工厂的超级工厂。

// 创建一个生产工厂的超级工厂FactoryProducer
public class FactoryProducer {
    public AbstractFactory getFactory(String factory){
        if(factory.equalsIgnoreCase("fruit")){
            return new FruitFactory();
        }else if (factory.equalsIgnoreCase("vehicle")){
            return new VehicleFactory();
        }
        return null;
    }
}

于是我们便通过这种方式创建了一个关于工厂模式的实例，如此我们便可以通过此方式创建不同工厂中的对象。

public class Main {
    public static void main(String[] args) {
        // 创建FactoryProducer对象，生产工厂对象
        FactoryProducer factoryProducer = new FactoryProducer();
        // 调用FactoryProducer中的方法生产水果工厂
        AbstractFactory fruitFactory = factoryProducer.getFactory("fruit");
        // 调用水果工厂的方法进而创建Apple对象
        Fruit apple = fruitFactory.getFruit("apple");
        // 调用Apple对象的方法
        apple.eat();

        // 调用FactoryProducer中的方法生产车辆工厂
        AbstractFactory vehicleFactory = factoryProducer.getFactory("vehicle");
        // 调用车辆工厂的方法进而创建bicycle对象
        Vehicle bicycle = vehicleFactory.getVehicle("bicycle");
        // 调用bicycle对象的方法
        bicycle.driver();
    }
}

运行结果如下图所示：

总结

简单工厂模式就是通过工厂类去帮助我们创建对象，我们只需要创建工厂类的对象，通过接收工厂类传入的数据进而创建我们需要的对象，而抽象工厂模式则是由于一个简单的工厂只能创建一个类型对象，而其他类型的对象则需要我们用其他的工厂，这就需要一个超级工厂去生产这些工厂对象，进而创建更多类型的对象。

如果本文对你有一些帮助，欢迎点赞收藏关注。更多内容也可以关注公众号”IT皮皮蟹“