【Java 设计模式】创建型之抽象工厂模式

在软件开发中，抽象工厂模式是一种常见的创建型设计模式，它提供了一种创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。抽象工厂模式的核心思想是将一组相关的产品组合成一个工厂，客户端通过工厂接口创建一系列产品。在本文中，我们将介绍 Java 设计模式中的抽象工厂模式，了解其定义、使用场景以及如何在实际开发中应用。

1. 定义

抽象工厂模式是一种创建型设计模式，它提供了一个接口，用于创建一系列相关或相互依赖的对象，而无需指定它们具体的类。抽象工厂模式将一组相关的产品组合成一个工厂，客户端通过工厂接口创建一系列产品。这有助于实现产品族的概念，其中产品族是指一组相关的产品，例如不同品牌的汽车。

2. 应用场景

抽象工厂模式的应用场景包括但不限于以下情况：

• 一系列相关产品：

  当有一系列相关或相互依赖的产品需要创建时，此时就可以使用抽象工厂模式，这有助于确保产品之间的兼容性和一致性

• 系统扩展性：

  当系统需要支持新的产品族时，只需新增对应的具体工厂类和产品类，而无需修改已有代码

• 隐藏具体实现：

  客户端只需关心抽象工厂和抽象产品的接口，不需要知道具体实现类，降低了客户端与具体类之间的耦合

3. 代码实现

抽象工厂模式的实现主要涉及以下几个角色：

• 抽象产品接口（AbstractProduct）： 定义了产品的抽象方法
• 具体产品实现类（ConcreteProduct）： 实现了抽象产品接口，是抽象工厂创建的具体对象
• 抽象工厂接口（AbstractFactory）： 定义了创建产品的抽象方法，可以包含多个不同的抽象产品接口
• 具体工厂实现类（ConcreteFactory）： 实现了抽象工厂接口，负责创建具体产品的对象

下面是一个简单的抽象工厂模式的实现示例：

1）创建一个产品接口 AbstractProductA 及它的两个实现类 ConcreteProductA1 和 ConcreteProductA2

AbstractProductA.java

package com.cheney.demo;

interface AbstractProductA {
    void operationA();
}

ConcreteProductA1.java

package com.cheney.demo;

class ConcreteProductA1 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("产品 A1");
    }
}

ConcreteProductA2.java

package com.cheney.demo;

class ConcreteProductA2 implements AbstractProductA {
    @Override
    public void operationA() {
        System.out.println("产品 A2");
    }
}

2）创建一个产品接口 AbstractProductB 及它的两个实现类 ConcreteProductB1 和 ConcreteProductB2

AbstractProductB.java

package com.cheney.demo;

interface AbstractProductB {
    void operationB();
}

ConcreteProductB1.java

package com.cheney.demo;

class ConcreteProductB1 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("产品 B1");
    }
}

ConcreteProductB2.java

package com.cheney.demo;

class ConcreteProductB2 implements AbstractProductB {
    @Override
    public void operationB() {
        System.out.println("产品 B2");
    }
}

3）创建一个产品接口 AbstractFactory 及它的两个实现类 ConcreteFactory1 和 ConcreteFactory2

AbstractProductB.java

interface AbstractFactory {
    AbstractProductA createProductA();
    AbstractProductB createProductB();
}

ConcreteFactory1.java

package com.cheney.demo;

class ConcreteFactory1 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

ConcreteFactory2.java

package com.cheney.demo;

class ConcreteFactory2 implements AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

在上述示例中，AbstractProductA 和 AbstractProductB 是抽象产品接口，定义了产品的抽象方法。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1 和 ConcreteProductB2 是具体产品的实现类。

AbstractFactory 是抽象工厂接口，定义了创建产品的抽象方法。ConcreteFactory1 和 ConcreteFactory2 是具体工厂的实现类，分别负责创建 ConcreteProductA1、ConcreteProductA2 和 ConcreteProductB1、ConcreteProductB2。

4. 应用示例

假设我们要吃可乐喝汉堡，需要支持不同店的美食。我们可以使用抽象工厂模式来管理不同店下的美食。

1）创建一个可乐接口 及它的两个实现类

Cola.java

package com.cheney.demo;

interface Cola {
    void makeCola();
}

KfcCola.java

package com.cheney.demo;

class KfcCola implements Cola {
    @Override
    public void makeCola() {
        System.out.println("肯德基的可乐");
    }
}

McDonaldSCola.java

package com.cheney.demo;

class McDonaldSCola implements Cola {
    @Override
    public void makeCola() {
        System.out.println("麦当劳的可乐");
    }
}

2）创建一个汉堡包接口 及它的两个实现类

Hamburger.java

package com.cheney.demo;

interface Hamburger {
    void makeHamburger();
}

KfcHamburger.java

package com.cheney.demo;

class KfcHamburger implements Hamburger {
    @Override
    public void makeHamburger() {
        System.out.println("肯德基的汉堡包");
    }
}

McDonaldSHamburger.java

package com.cheney.demo;

class McDonaldSHamburger implements Hamburger {
    @Override
    public void makeHamburger() {
        System.out.println("麦当劳的汉堡包");
    }
}

3）创建一个美食工厂接口 及 它的两个实现类

FoodFactory.java

package com.cheney.demo;

interface FoodFactory {
    Cola createCola();
    Hamburger createHamburger();
}

KfcFoodFactory.java

package com.cheney.demo;

class KfcFoodFactory implements FoodFactory {
    @Override
    public Cola createCola() {
        return new KfcCola();
    }

    @Override
    public Hamburger createHamburger() {
        return new KfcHamburger();
    }
}

McDonaldSFoodFactory.java

package com.cheney.demo;

class McDonaldSFoodFactory implements FoodFactory {
    @Override
    public Cola createCola() {
        return new McDonaldSCola();
    }

    @Override
    public Hamburger createHamburger() {
        return new McDonaldSHamburger();
    }
}

在上述示例中，Cola 和 Hamburger 是抽象产品接口，定义了产品的抽象方法。KfcCola、KfcHamburger、McDonaldSCola 和 McDonaldSHamburger 是具体产品的实现类。

FoodFactory 是抽象工厂接口，定义了创建产品的抽象方法。KfcFoodFactory 和 McDonaldSFoodFactory 是具体工厂的实现类，分别负责创建KfcCola、KfcHamburger、McDonaldSCola 和 McDonaldSHamburger

在使用中，我们可以根据需要选择不同的工厂来创建不同店里的美食

package com.cheney.demo;

public class Main {
    public static void main(String[] args) {
        // 创建 麦当劳系列 美食
        FoodFactory mcDonaldSFoodFactory = new McDonaldSFoodFactory();
        Cola mcDonaldSCola = mcDonaldSFoodFactory.createCola();
        Hamburger mcDonaldSHamburger = mcDonaldSFoodFactory.createHamburger();
        mcDonaldSCola.makeCola();
        mcDonaldSHamburger.makeHamburger();

        // 创建 肯德基系列 美食
        FoodFactory kfcFoodFactory = new KfcFoodFactory();
        Cola kfcCola = kfcFoodFactory.createCola();
        Hamburger kfcHamburger = kfcFoodFactory.createHamburger();
        kfcCola.makeCola();
        kfcHamburger.makeHamburger();
    }
}

执行结果

结语

抽象工厂模式是一种常见且实用的设计模式，它通过定义一个工厂接口，将一系列相关或相互依赖的对象的创建延迟到具体工厂的实现类中，从而实现了客户端和具体类的解耦。在实际开发中，抽象工厂模式常用于创建一系列相关的产品，如美食店中的可乐、汉堡包等。通过合理使用抽象工厂模式，可以使系统更容易扩展和维护。