工厂模式（Factory Pattern）和抽象工厂模式（Abstract Factory Pattern）都是创建型设计模式，旨在提供对象创建的灵活性，避免硬编码的类实例化。尽管它们都用于创建对象，但它们在适用场景和实现方式上有所不同。

以下是它们的区别和示例：

1. 工厂模式（Factory Pattern）

定义：

工厂模式定义了一个创建对象的接口，但由子类决定实例化哪一个类。工厂模式将对象的创建过程封装到一个方法中，客户端通过工厂方法来获取对象，而不需要直接使用 new 来实例化具体的类。

特点：

只负责创建单个对象。

对象的创建依赖于工厂类，可以通过继承来定制具体的产品。

客户端不需要知道具体类的创建细节，只需调用工厂方法。

示例：

假设我们有一个动物类 Animal，并且需要根据类型来创建具体的动物对象：

// 产品接口public interface Animal {    void speak();}
// 具体产品：Dogpublic class Dog implements Animal {    @Override    public void speak() {        System.out.println("Woof!");    }}
// 具体产品：Catpublic class Cat implements Animal {    @Override    public void speak() {        System.out.println("Meow!");    }}
// 工厂类public class AnimalFactory {    public Animal createAnimal(String type) {        if (type.equals("dog")) {            return new Dog();        } else if (type.equals("cat")) {            return new Cat();        }        return null;    }}

使用工厂：

public class Main {    public static void main(String[] args) {        AnimalFactory factory = new AnimalFactory();        Animal dog = factory.createAnimal("dog");        dog.speak();  // 输出: Woof!                Animal cat = factory.createAnimal("cat");        cat.speak();  // 输出: Meow!    }}

2. 抽象工厂模式

（Abstract Factory Pattern）

定义：

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它允许客户端通过一组工厂方法来创建一组对象，而不需要关心具体实现类。

特点：

提供多个相关的产品族。

每个产品族中的产品是互相关联的，可以保证创建一组对象。

客户端通过抽象工厂接口来获取产品，而不关心具体的产品类。

示例：

假设我们要创建一系列家具产品，包括椅子和沙发，且这些产品有不同的风格（例如现代和古典风格）：

// 抽象产品接口public interface Chair {    void sitOn();}
public interface Sofa {    void lieOn();}
// 具体产品：Modern Chairpublic class ModernChair implements Chair {    @Override    public void sitOn() {        System.out.println("Sitting on a modern chair.");    }}
// 具体产品：Modern Sofapublic class ModernSofa implements Sofa {    @Override    public void lieOn() {        System.out.println("Lying on a modern sofa.");    }}
// 具体产品：Classic Chairpublic class ClassicChair implements Chair {    @Override    public void sitOn() {        System.out.println("Sitting on a classic chair.");    }}
// 具体产品：Classic Sofapublic class ClassicSofa implements Sofa {    @Override    public void lieOn() {        System.out.println("Lying on a classic sofa.");    }}
// 抽象工厂接口public interface FurnitureFactory {    Chair createChair();    Sofa createSofa();}
// 具体工厂：ModernFurnitureFactorypublic class ModernFurnitureFactory implements FurnitureFactory {    @Override    public Chair createChair() {        return new ModernChair();    }
    @Override    public Sofa createSofa() {        return new ModernSofa();    }}
// 具体工厂：ClassicFurnitureFactorypublic class ClassicFurnitureFactory implements FurnitureFactory {    @Override    public Chair createChair() {        return new ClassicChair();    }
    @Override    public Sofa createSofa() {        return new ClassicSofa();    }}

使用抽象工厂：

public class Main {    public static void main(String[] args) {        FurnitureFactory factory = new ModernFurnitureFactory();        Chair modernChair = factory.createChair();        Sofa modernSofa = factory.createSofa();        modernChair.sitOn();   // 输出: Sitting on a modern chair.        modernSofa.lieOn();    // 输出: Lying on a modern sofa.
        factory = new ClassicFurnitureFactory();        Chair classicChair = factory.createChair();        Sofa classicSofa = factory.createSofa();        classicChair.sitOn();  // 输出: Sitting on a classic chair.        classicSofa.lieOn();   // 输出: Lying on a classic sofa.    }}

3. 区别总结

特性	工厂模式（Factory Pattern）	抽象工厂模式（Abstract Factory Pattern）
目的	用于创建一个产品（对象）。	用于创建一系列相关或相互依赖的对象。
产品种类	创建单一产品对象。	创建一系列相关的产品对象。
复杂度	较简单，适合产品较少的情况。	较复杂，适合需要多个产品族（多个相关对象）时使用。
适用场景	当你需要根据条件创建不同类型的对象时使用。	当你需要创建一系列相关的对象（如不同风格的家具、操作系统等）时使用。
示例	AnimalFactory：根据动物类型创建不同动物对象。	FurnitureFactory：根据家具风格创建一系列的椅子和沙发对象。

👋 大家好，我是枫哥，一名Java后端开发者！我热衷于探索新技术，并在我的微信公众号上分享关于Java 生态和后端开发的知识。欢迎关注我的公众号，期待与你一起探讨技术的无穷可能！” 目前专注于Java技术分享，覆盖春招、秋招、社招和跳槽相关内容，并提供一对一带徒学习服务。加入学徒计划，即可享受内推机会和优质资源，签订协议确保就业无忧。此外，我们还推出了‘Java跳槽网’，为你的求职之路提供全方位支持，助你快速找到理想工作

END

ITPub博客

工厂模式看这一篇文章就够了

最新文章