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

什么是工厂模式？

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

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

简单工厂模式

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

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

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

// 定义车辆的接口
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皮皮蟹“