设计模式--工厂模式

Liu_Junwei

于 2024-08-27 17:37:29 发布

阅读量296

点赞数 6

分类专栏：设计模式文章标签：设计模式 java

本文链接：https://blog.csdn.net/m0_62965917/article/details/141608592

版权

设计模式专栏收录该内容

6 篇文章 0 订阅

订阅专栏

工厂模式（Factory Pattern）是一种创建型设计模式，用于创建对象时不暴露对象创建的具体逻辑。它提供了一种将对象创建的职责交给工厂对象的方式，使得客户端代码与具体的类解耦。

工厂模式的主要类型:

简单工厂模式（Simple Factory Pattern）：提供一个工厂类来创建对象，客户端只需要提供对象的参数，工厂类根据这些参数决定创建哪种具体的产品对象。
工厂方法模式（Factory Method Pattern）：定义一个创建对象的接口，让子类决定实例化哪个类。工厂方法模式通过子类化来创建对象。
抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。它用于创建多个相关的对象，而不仅仅是单一对象。

1. 简单工厂模式

优点：

对客户端代码隐藏了具体的创建细节，简化了客户端代码。
可以集中管理对象创建的逻辑，易于维护。

缺点：

工厂类变得复杂，难以扩展和维护。
不符合开闭原则，如果需要新增产品，需要修改工厂类。

实现：

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

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

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

// 简单工厂类
public class SimpleFactory {
    public static Product createProduct(String type) {
        switch (type) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Unknown product type");
        }
    }
}

2. 工厂方法模式

优点：

工厂方法模式符合开闭原则，增加新产品时，只需要新增具体工厂类，不需要修改现有工厂代码。
每个具体工厂类可以创建不同的产品，灵活性更高。

缺点：

增加了类的数量，系统复杂度提升。
需要定义一个工厂接口和多个具体工厂类。

实现：

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

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

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

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

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

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

3. 抽象工厂模式

优点：

可以创建多个相关或依赖的对象，提供一致的接口。
易于扩展，符合开闭原则。

缺点：

增加了系统的复杂性，需要创建多个工厂接口和具体工厂类。
如果产品族增加，工厂类和接口也需要增加。

实现：

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

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

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

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

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

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

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

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

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

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

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