【Java 设计模式】创建型之抽象工厂模式-Toy模板网

这篇具有很好参考价值的文章主要介绍了【Java 设计模式】创建型之抽象工厂模式。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

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

1. 定义

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

2. 应用场景

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

一系列相关产品：

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

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

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

3. 代码实现

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

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

抽象产品接口（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();
    }
}

执行结果

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

结语

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

【Java 设计模式】系列《23 种设计模式》与《7 大设计原则》总纲
🚩设计原则
✨单一职责原则（SRP）规定一个类应该只有一个引起变化的原因
✨开放/封闭原则（OCP）表明软件实体应该是可以扩展的，但是不可修改的
✨里氏替换原则（LSP）强调派生类必须能够替代其基类而不引起程序错误
✨依赖倒置原则（DIP）倡导高层模块不应该依赖于低层模块，二者都应该依赖于抽象
✨接口隔离原则（ISP）提倡一个类不应该被强迫依赖它不使用的接口
✨合成/聚合复用原则（CARP）建议尽量使用合成/聚合，尽量不要使用继承
✨迪米特法则（LoD）规定一个对象应该对其他对象有最少的了解

🚀创建型设计模式
✨单例模式保证一个类仅有一个实例，并提供一个访问它的全局点
✨工厂方法模式定义一个用于创建对象的接口，但是由子类决定实例化哪一个类
✨抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类
✨建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示
✨原型模式通过复制现有的对象来创建新对象，而不是从头开始创建

🚀结构型设计模式
✨适配器模式将一个类的接口转换成客户希望的另外一个接口
✨桥接模式将抽象部分与它的实现部分分离，使它们都可以独立地变化
✨组合模式将对象以树形结构组合以表示“部分-整体”的层次结构
✨装饰器模式动态地给一个对象添加一些额外的职责
✨外观模式为子系统中的一组接口提供一个一致的界面
✨代理模式为其他对象提供一种代理以控制对这个对象的访问
✨享元模式用共享的方式高效地支持大量小粒度对象

🚀行为型设计模式
✨观察者模式定义对象间的一对多依赖，当一个对象改变状态，所有依赖者都会受到通知并自动更新
✨策略模式定义一系列算法，将它们封装起来，并且使它们可以相互替换
✨命令模式将请求封装成对象，使得可以用不同的请求对客户进行参数化
✨状态模式允许对象在其内部状态改变时改变它的行为
✨责任链模式为解除请求的发送者和接收者之间的耦合，而使多个对象都有机会处理这个请求
✨访问者模式将算法与对象结构分离，并且可以在不改变对象结构的前提下定义新的操作
✨中介者模式用一个中介对象来封装一系列的对象交互
✨备忘录模式在不破坏封装的情况下，捕获对象的内部状态，并在对象之外保存这个状态
✨迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而不暴露其内部表示
✨模版方法模式定义一个操作中的算法的骨架，将一些步骤延迟到子类中
✨解释器模式定义一个语言的文法，并且建立一个解释器来解释该语言中的句子

文章来源地址https://www.toymoban.com/news/detail-797439.html

到了这里，关于【Java 设计模式】创建型之抽象工厂模式的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！