Java中工厂模式和抽象工厂模式的区别

唐人街都是苦瓜脸

于 2025-04-11 19:58:22 发布

阅读量515

点赞数 3

文章标签： java 抽象工厂模式简单工厂模式

本文链接：https://blog.youkuaiyun.com/xiaoyezhiei/article/details/147153224

版权

Java中工厂模式和抽象工厂模式的区别

在 Java 中，工厂模式和抽象工厂模式的区别主要体现在它们的抽象层次和创建对象的方式。

1. 工厂模式（Factory Method Pattern）

定义：
工厂模式定义了一个接口，用来创建对象，但由子类决定实例化哪个类。工厂方法让客户端不需要关心具体对象的创建过程，只需要调用工厂方法。
特点：
通过工厂方法来创建对象。
每个具体的工厂类负责创建一个具体的产品。
适用于创建一个对象的场景。

2. 抽象工厂模式（Abstract Factory Pattern）

定义：
抽象工厂模式提供一个接口，用于创建一系列相关或依赖的对象，而不需要指定具体的类。它比工厂模式更为复杂，通常用于创建一组相关的对象。
特点：
提供多个方法来创建一组相关产品。
客户端通过抽象工厂来创建多个相关产品，而不关心具体的类。
适用于创建多个产品系列的场景。

区别总结：

工厂模式：用于创建一个单一对象。
抽象工厂模式：用于创建一组相关或依赖的对象，通常是多个产品。

通俗易懂的例子：

假设你正在设计一个家具工厂，这个工厂生产不同类型的家具，比如椅子和沙发。你可以使用工厂模式和抽象工厂模式来设计这个系统。

1. 工厂模式（Factory Method Pattern）示例：

在工厂模式中，我们只有一个工厂来生产一种产品，假设这个产品是椅子，工厂通过工厂方法来创建椅子。

// 产品接口
interface Furniture {
    void create();
}

// 具体产品类 - 椅子
class Chair implements Furniture {
    @Override
    public void create() {
        System.out.println("Creating a chair");
    }
}

// 具体产品类 - 沙发
class Sofa implements Furniture {
    @Override
    public void create() {
        System.out.println("Creating a sofa");
    }
}

// 工厂接口
interface FurnitureFactory {
    Furniture createFurniture();
}

// 具体工厂类 - 椅子工厂
class ChairFactory implements FurnitureFactory {
    @Override
    public Furniture createFurniture() {
        return new Chair();
    }
}

// 具体工厂类 - 沙发工厂
class SofaFactory implements FurnitureFactory {
    @Override
    public Furniture createFurniture() {
        return new Sofa();
    }
}

// 客户端代码
public class FactoryMethodExample {
    public static void main(String[] args) {
        FurnitureFactory chairFactory = new ChairFactory();
        Furniture chair = chairFactory.createFurniture();
        chair.create();  // 输出: Creating a chair

        FurnitureFactory sofaFactory = new SofaFactory();
        Furniture sofa = sofaFactory.createFurniture();
        sofa.create();  // 输出: Creating a sofa
    }
}

总结：

在这个例子中，ChairFactory 和 SofaFactory 是单独的工厂，每个工厂负责创建一个具体的家具对象。在这种情况下，工厂模式适合创建一个产品（如椅子或沙发）。

2. 抽象工厂模式（Abstract Factory Pattern）示例：

在抽象工厂模式中，我们不仅创建单一的产品（如椅子或沙发），而是创建一系列相关产品，例如创建一个现代风格或经典风格的家具系列。每个系列包括不同的家具（椅子、沙发等）。

// 产品接口
interface Chair {
    void create();
}

interface Sofa {
    void create();
}

// 具体产品类 - 现代风格椅子
class ModernChair implements Chair {
    @Override
    public void create() {
        System.out.println("Creating a modern chair");
    }
}

// 具体产品类 - 经典风格椅子
class ClassicChair implements Chair {
    @Override
    public void create() {
        System.out.println("Creating a classic chair");
    }
}

// 具体产品类 - 现代风格沙发
class ModernSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("Creating a modern sofa");
    }
}

// 具体产品类 - 经典风格沙发
class ClassicSofa implements Sofa {
    @Override
    public void create() {
        System.out.println("Creating a classic sofa");
    }
}

// 抽象工厂接口
interface FurnitureFactory {
    Chair createChair();
    Sofa createSofa();
}

// 具体工厂类 - 现代风格家具工厂
class ModernFurnitureFactory implements FurnitureFactory {
    @Override
    public Chair createChair() {
        return new ModernChair();
    }

    @Override
    public Sofa createSofa() {
        return new ModernSofa();
    }
}

// 具体工厂类 - 经典风格家具工厂
class ClassicFurnitureFactory implements FurnitureFactory {
    @Override
    public Chair createChair() {
        return new ClassicChair();
    }

    @Override
    public Sofa createSofa() {
        return new ClassicSofa();
    }
}

// 客户端代码
public class AbstractFactoryExample {
    public static void main(String[] args) {
        FurnitureFactory modernFactory = new ModernFurnitureFactory();
        Chair modernChair = modernFactory.createChair();
        Sofa modernSofa = modernFactory.createSofa();
        modernChair.create();  // 输出: Creating a modern chair
        modernSofa.create();   // 输出: Creating a modern sofa

        FurnitureFactory classicFactory = new ClassicFurnitureFactory();
        Chair classicChair = classicFactory.createChair();
        Sofa classicSofa = classicFactory.createSofa();
        classicChair.create();  // 输出: Creating a classic chair
        classicSofa.create();   // 输出: Creating a classic sofa
    }
}