Java中如何实现工厂模式创建对象

小婷大大_5577

发布时间：2025-06-25 23:55:01

651人浏览过

来源于php中文网

原创

工厂模式通过封装对象创建过程来降低耦合，提高灵活性和可维护性。1. 简单工厂模式将创建逻辑集中在一个工厂类中，优点是简单易懂，缺点是违反开闭原则；2. 工厂方法模式通过定义创建接口并由子类实现，遵循开闭原则且易于扩展，但需要创建多个工厂类；3. 抽象工厂模式用于创建一组相关或依赖对象，支持产品族的切换，但增加类数量且扩展困难。当类不确定需创建的对象、希望由子类指定创建或需切换相关对象组时应使用工厂模式。工厂模式可通过解耦依赖关系辅助实现依赖注入。选择时根据需求复杂度判断：简单场景用简单工厂，多类型或需扩展用工厂方法，多产品族用抽象工厂。

Java中如何实现工厂模式创建对象

工厂模式，简单来说，就是把对象的创建过程封装起来，让客户端代码不需要直接new对象，而是通过工厂来获取。这样可以降低耦合，提高代码的灵活性和可维护性。

解决方案

工厂模式的核心在于定义一个工厂接口或抽象类，然后由具体的工厂类来实现对象的创建。

立即学习“Java免费学习笔记（深入）”；

简单工厂模式（Simple Factory Pattern）

简单工厂模式实际上不是一个设计模式，而是一种编程习惯。它将对象的创建逻辑集中在一个工厂类中。

// 产品接口
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 简单工厂
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        } else {
            return null; // 或者抛出异常
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        if (productA != null) {
            productA.use();
        }

        Product productB = SimpleFactory.createProduct("B");
        if (productB != null) {
            productB.use();
        }
    }
}

优点： 简单易懂。
缺点： 违反开闭原则，如果需要增加新的产品，需要修改工厂类的代码。

工厂方法模式（Factory Method Pattern）

Java Maven Code Review

审查Java Maven项目（ZIP压缩包或GitLab仓库URL），检查代码规范、命名、模块边界、可维护性问题以及重复代码。

下载

工厂方法模式定义一个创建对象的接口，但将实际创建对象的工作推迟到子类。每个具体工厂负责创建一个具体产品。

// 抽象产品
interface Product {
    void use();
}

// 具体产品A
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductB");
    }
}

// 抽象工厂
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

优点： 遵循开闭原则，易于扩展。
缺点： 需要创建多个工厂类，增加了类的数量。

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。可以理解为工厂方法模式的升级版，解决创建多个产品族的问题。

// 抽象产品A
interface ProductA {
    void use();
}

// 抽象产品B
interface ProductB {
    void operate();
}

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using ConcreteProductA2");
    }
}

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating ConcreteProductB1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    @Override
    public void operate() {
        System.out.println("Operating ConcreteProductB2");
    }
}

// 抽象工厂
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.operate();

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.operate();
    }
}