工厂模式（详解）

目录

一、什么是工厂模式？

二、工厂模式的类型

1. 简单工厂模式

2. 工厂方法模式

三、总结

---

工厂模式

在软件设计中，设计模式是一种被反复使用的、经过验证的解决方案。工厂模式（Factory Pattern）是一种常见的创建型设计模式，它提供了一种创建对象的最佳方式。本文将详细介绍工厂模式，包括其定义、类型、优缺点及其实现方式。

一、什么是工厂模式？

工厂模式是一种创建对象的设计模式，它定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂模式让类的实例化推迟到子类。

简单来说，工厂模式通过创建一个专门负责创建对象的工厂类，将对象的创建过程封装起来，以此达到解耦的目的。

二、工厂模式的类型

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

1. 简单工厂模式（Simple Factory Pattern）
2. 工厂方法模式（Factory Method Pattern）
3. 抽象工厂模式（Abstract Factory Pattern）

1. 简单工厂模式

简单工厂模式由一个工厂类根据传入的参数，决定创建哪一种具体产品类的实例。

优点：

• 客户端不需要知道创建对象的具体类，只需知道工厂类和产品类的接口即可。

缺点：

• 工厂类的职责过重，增加新的产品时需要修改工厂类，违反了开闭原则。

简单的工厂模式类图：

 

示例代码 

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

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

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

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

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

 

2. 工厂方法模式

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。这样，工厂方法模式将实例化操作推迟到子类。

优点：

• 遵循开闭原则，可以在不修改现有代码的情况下添加新产品。

缺点：

• 增加了系统的复杂性，需要为每个产品创建一个工厂类。

工厂方法模式类图：

 

示例代码： 

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

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

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

// 抽象工厂类
public abstract class Factory {
    public abstract Product createProduct();
}

// 具体工厂A
public class FactoryA extends Factory {
    public Product createProduct() {
        return new ProductA();
    }
}

// 具体工厂B
public class FactoryB extends Factory {
    public Product createProduct() {
        return new ProductB();
    }
}

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

 

3. 抽象工厂模式

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。它能够创建多个系列的产品，而不是单一产品。

优点：

• 分离了具体类的生成，符合开闭原则。
• 提供了一个一致的产品族创建方式。

缺点：

• 增加了系统的抽象性和复杂性。

抽象工厂模式的类图：

 

示例代码： 

// 产品A接口
public interface ProductA {
    void use();
}

// 产品B接口
public interface ProductB {
    void eat();
}

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

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

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

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

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

// 具体工厂1
public class Factory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA1();
    }
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂2
public class Factory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ProductA2();
    }
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        AbstractFactory factory1 = new Factory1();
        ProductA productA1 = factory1.createProductA();
        ProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.eat();
        
        AbstractFactory factory2 = new Factory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.eat();
    }
}

三、总结 

 工厂模式在实际开发中应用广泛，通过将对象的创建逻辑集中到一个工厂类中，可以有效地降低系统的耦合度，提高代码的可维护性。无论是简单工厂模式、工厂方法模式还是抽象工厂模式，它们都有各自的优缺点，开发者可以根据具体的需求选择合适的模式。

希望本文能帮助你更好地理解工厂模式，并在实际项目中灵活应用。如果你有任何问题或建议，欢迎在评论区留言讨论！