Java设计模式之工厂模式

工厂模式(Factory Pattern)是一种创建型设计模式,它提供了创建对象的最佳方式之一。工厂模式使用工厂类来创建对象,而不是通过直接调用构造函数来实例化对象。这样做的好处是可以将对象的创建和使用分离,提供更好的灵活性和可扩展性。

工厂模式主要分为三种类型:

  1. 简单工厂模式(Simple Factory Pattern)

  2. 工厂方法模式(Factory Method Pattern)

  3. 抽象工厂模式(Abstract Factory Pattern)

1. 简单工厂模式

简单工厂模式通过一个工厂类,根据传入的参数决定创建哪种类型的实例。尽管简单工厂模式不是23种经典的设计模式之一,但它依然广泛使用。

示例代码:

java 复制代码
// 产品接口
interface Product {
    void use();
}

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

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

// 简单工厂类
class SimpleFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

// 客户端代码
public class SimpleFactoryPatternDemo {
    public static void main(String[] args) {
        SimpleFactory factory = new SimpleFactory();
        Product productA = factory.createProduct("A");
        productA.use();

        Product productB = factory.createProduct("B");
        productB.use();
    }
}

2. 工厂方法模式

工厂方法模式定义了一个用于创建对象的接口,但由子类决定实例化哪一个类。工厂方法让一个类的实例化延迟到其子类。

java 复制代码
示例代码:


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

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

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

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

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

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

// 客户端代码
public class FactoryMethodPatternDemo {
    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();
    }
}

3. 抽象工厂模式

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。它可以看作是工厂方法模式的进一步推广。

示例代码:

java 复制代码
// 产品族接口
interface ProductA {
    void use();
}

interface ProductB {
    void eat();
}

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

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

// 具体产品类B1
class ConcreteProductB1 implements ProductB {
    public void eat() {
        System.out.println("Eating Product B1");
    }
}

// 具体产品类B2
class ConcreteProductB2 implements ProductB {
    public void eat() {
        System.out.println("Eating Product B2");
    }
}

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

// 具体工厂类1
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }
    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂类2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }
    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

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

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

总结

工厂模式通过将对象的创建过程封装在工厂类中,使得代码更具扩展性和维护性。具体使用哪种工厂模式,取决于应用的复杂度和需求:

  • 简单工厂模式:适用于简单的对象创建需求,结构简单但不具备扩展性。

  • 工厂方法模式:适用于需要多个具体工厂来创建不同对象的情况,具备较好的扩展性。

  • 抽象工厂模式:适用于需要创建一系列相关或相互依赖的对象的情况,提供了最高的灵活性和扩展性。

相关推荐
艾莉丝努力练剑6 分钟前
【C语言】学习过程教训与经验杂谈:思想准备、知识回顾(三)
c语言·开发语言·数据结构·学习·算法
Chasing__Dreams12 分钟前
python--杂识--18.1--pandas数据插入sqlite并进行查询
python·sqlite·pandas
彭泽布衣1 小时前
python2.7/lib-dynload/_ssl.so: undefined symbol: sk_pop_free
python·sk_pop_free
邓不利东1 小时前
Spring中过滤器和拦截器的区别及具体实现
java·后端·spring
witton2 小时前
Go语言网络游戏服务器模块化编程
服务器·开发语言·游戏·golang·origin·模块化·耦合
喜欢吃豆2 小时前
从零构建MCP服务器:FastMCP实战指南
运维·服务器·人工智能·python·大模型·mcp
草履虫建模2 小时前
Redis:高性能内存数据库与缓存利器
java·数据库·spring boot·redis·分布式·mysql·缓存
苹果醋32 小时前
Vue3组合式API应用:状态共享与逻辑复用最佳实践
java·运维·spring boot·mysql·nginx
一个处女座的测试2 小时前
Python语言+pytest框架+allure报告+log日志+yaml文件+mysql断言实现接口自动化框架
python·mysql·pytest
枯萎穿心攻击2 小时前
ECS由浅入深第三节:进阶?System 的行为与复杂交互模式
开发语言·unity·c#·游戏引擎