Java设计模式【简单工厂、工厂模式、抽象工厂】-创建型

原创已于 2024-06-27 00:36:41 修改 · 396 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式 #开发语言

于 2024-06-27 00:11:02 首次发布

Java 专栏收录该内容

18 篇文章

订阅专栏

介绍

工厂模式（Factory Pattern）是创建型设计模式的一种，它提供了一种创建对象的方式，而无需在代码中明确指定具体类。工厂模式主要有三种形式：简单工厂模式、工厂方法模式和抽象工厂模式。

应用场景

1、简单工厂

创建简单对象：当对象的创建逻辑简单且对象不多时使用。
替代复杂的构造器：当构造器参数过多或复杂时，可以使用工厂方法来替代复杂的构造器调用。
隐藏对象创建细节：对客户端隐藏对象创建的细节，提高代码的可维护性。

2、工厂模式

对象创建有复杂逻辑：当对象的创建过程包含复杂的逻辑或依赖于具体的环境时使用。
系统中有多种产品系列：当系统中有多种产品系列，每个系列需要单独创建时使用。
产品的创建需要子类来扩展：当需要由子类来决定实例化哪一个类时使用。

3、抽象工厂模式

创建一系列相关或相互依赖的对象：当系统需要创建一系列相关或相互依赖的对象时使用。
产品族的创建：当系统有多个产品族，并且需要创建属于同一个产品族的对象时使用。
产品族的变化：当需要增加或变化产品族，而不影响使用者时使用。

Java实现示例

1、简单工厂模式是指由一个工厂类根据传入的参数决定创建哪种具体类的实例

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

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

// 具体产品B
public class ProductB 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 ProductA();
            case "B":
                return new ProductB();
            default:
                throw new IllegalArgumentException("Unknown product type: " + type);
        }
    }
}

// 客户端代码
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 {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

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

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

    public void doSomething() {
        Product product = createProduct();
        product.use();
    }
}

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Factory factoryA = new FactoryA();
        factoryA.doSomething();

        Factory factoryB = new FactoryB();
        factoryB.doSomething();
    }
}

3、抽象工厂模式提供了一个接口，用于创建一系列相关或依赖的对象，而无需指定它们的具体类。它通常用于创建一组相关的产品。

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

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

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

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

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

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

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

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

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

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

    @Override
    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.consume();

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