首页 > 其他分享 >工厂模式和策略模式的区别

工厂模式和策略模式的区别

时间：2024-08-25 20:50:54浏览次数：7  
标签：策略 区别 void 模式 工厂 算法 public

工厂模式和策略模式的区别

工厂模式和策略模式的区别

工厂模式和策略模式的区别

1. 引言

1.1 背景介绍

在软件开发中，设计模式是解决特定问题的成熟方案。它们提供了一种通用的模板来解决在软件设计过程中遇到的常见问题。工厂模式和策略模式是两种广泛使用的设计模式，它们都旨在提高代码的可维护性和可扩展性，但它们解决问题的方式和应用场景有所不同。

工厂模式主要用于处理对象创建的问题，它提供了一种机制来封装对象的创建过程，使得客户端代码不需要知道具体的类是如何被实例化的。这种模式特别适用于当对象的创建过程复杂或者需要根据条件创建不同类型的对象时。

策略模式则关注算法的选择和切换。它允许在运行时选择不同的算法或行为，而不需要修改使用算法的代码。这种模式使得算法可以独立于使用它们的客户端变化，从而提高了代码的灵活性。

1.2 研究意义

理解工厂模式和策略模式的区别对于软件工程师来说至关重要，因为它们可以帮助工程师在设计软件系统时做出更合适的架构决策。正确地应用这些模式可以减少代码的耦合度，提高代码的可重用性和可测试性。

工厂模式和策略模式的选择和应用对于软件的长期维护和扩展也非常重要。随着软件系统的不断增长和变化，能够灵活地应对新需求的模式将大大提高软件的适应性和生命力。

此外，研究这两种模式的区别也有助于开发者更深入地理解面向对象设计的原则，如封装变化、单一职责原则和开闭原则等。这些原则是设计高质量软件的基础。

在本文中，我们将深入探讨工厂模式和策略模式的定义、分类、相似之处、区别以及它们在实际应用中的案例分析，以帮助读者更好地理解和应用这些模式。

2. 工厂模式概述

2.1 工厂模式定义

工厂模式是一种创建型设计模式，其核心思想是通过创建一个工厂类来封装对象的创建过程。这样，当需要创建对象时，只需调用工厂类的创建方法，而无需关心对象的具体创建细节。工厂模式主要目的是提供一个接口用于创建对象，让子类决定实例化哪一个类。工厂模式使得程序在判断对象类型时更加灵活，并且能够轻松地扩展新的类型。

2.2 工厂模式分类

工厂模式可以根据其复杂性和使用场景被分为三种主要类型：简单工厂模式、工厂方法模式和抽象工厂模式。

2.2.1 简单工厂模式

简单工厂模式并不是一个真正的设计模式，而是一种编程习惯。它通常由一个工厂类根据传入的参数，返回不同类的实例。这种模式的缺点是工厂类职责过重，每次添加新的产品都需要修改工厂类的逻辑，违反了开闭原则。

特点：

  • 工厂类的职责过重，一旦添加新产品就需要修改工厂类的逻辑。
  • 客户端需要知道工厂类，违反了依赖倒置原则。
2.2.2 工厂方法模式

工厂方法模式定义了一个创建对象的接口，但让实现这个接口的类来决定实例化哪一个类。工厂方法模式把一个类的实例化推迟到其子类。这种方式让类的实例化推迟到子类进行，子类可以通过重写工厂方法来创建其实例。

特点：

  • 工厂方法让类的实例化推迟到子类进行。
  • 支持开闭原则，当新增产品时，只需增加新的具体产品类和相应的工厂子类，无需修改已有代码。
2.2.3 抽象工厂模式

抽象工厂模式提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。这种模式主要用于当有多个产品族，而每次只使用其中一族时的场景。

特点：

  • 可以创建一系列相关或相互依赖的对象，而不需要指定它们具体的类。
  • 抽象工厂模式允许系统在不指定具体类的情况下，通过配置文件或参数来改变系统所创建的对象类型。

通过这三种工厂模式的分类，开发者可以根据不同的设计需求选择合适的工厂模式来实现对象的创建，从而提高代码的灵活性和可维护性。

3. 策略模式概述

3.1 策略模式定义

策略模式是一种行为型设计模式，它定义了一系列的算法，并将每一个算法封装起来，使它们可以互换使用。这种模式允许算法独立于使用它们的客户端变化，也就是说，策略模式使得算法可以在运行时被选择和更换。

策略模式的主要目的是将算法的使用和算法的实现分离开来，这样算法可以独立于客户端变化。它通常涉及到定义一个策略接口，该接口由不同的策略类实现，客户端通过这个接口与具体的策略类交互，而不需要知道具体的算法实现细节。

3.2 策略模式组成

策略模式通常包含以下几个主要组成部分：

  1. 策略接口（Strategy Interface）：这是一个定义了所有支持的算法的公共接口，通常包含一个或多个执行算法的方法。

  2. 具体策略类（Concrete Strategy）：这些类实现了策略接口，并封装了具体的算法或行为。

  3. 上下文（Context）：上下文是使用策略接口的类，它维护一个对策略对象的引用。上下文通过策略接口与具体的策略类交互，从而使得算法可以独立于使用它的客户端变化。

  4. 客户端（Client）：客户端通常创建具体的策略对象，并将其传递给上下文。客户端可以选择不同的策略来影响上下文的行为。

策略模式的工作流程如下：

  1. 定义策略接口，声明执行算法的方法。
  2. 实现具体的策略类，这些类实现策略接口，并提供算法的具体实现。
  3. 创建上下文类，它包含一个对策略接口的引用，并定义了一个方法，该方法接受策略对象作为参数。
  4. 客户端根据需要创建具体的策略对象，并将它们传递给上下文，从而改变上下文的行为。

通过使用策略模式，系统的行为或算法可以灵活地在运行时进行更换，而不需要修改使用算法的代码，这大大提高了代码的灵活性和可维护性。

4. 工厂模式与策略模式的相似之处

4.1 都是设计模式

工厂模式和策略模式都是面向对象设计模式的一部分，它们遵循设计模式的一般原则，如封装变化、提高代码的可扩展性和可维护性。这些模式提供了一种通用的解决方案，用于解决在软件开发过程中遇到的常见问题。

  • 封装变化：两种模式都通过将变化的部分封装起来，减少系统各部分之间的耦合，使得系统更容易适应变化。
  • 代码复用：它们都支持代码的复用。工厂模式通过创建对象的接口来复用对象创建代码，而策略模式通过算法的封装来复用算法实现。

4.2 都用于提高代码的灵活性和可维护性

工厂模式和策略模式都旨在提高代码的灵活性和可维护性，但它们关注的焦点不同。

  • 灵活性：工厂模式通过将对象的创建逻辑封装在工厂类中，使得对象的创建更加灵活，客户端代码不需要知道具体的类是如何被实例化的。策略模式通过封装算法，使得算法可以在运行时更换，提高了算法使用的灵活性。

  • 可维护性：工厂模式通过将对象创建逻辑集中管理，简化了对象创建过程，使得代码更容易理解和维护。策略模式通过将算法封装在独立的策略类中，使得算法的变化不会影响到使用算法的代码，从而提高了代码的可维护性。

尽管工厂模式和策略模式在提高代码灵活性和可维护性方面有相似之处，但它们解决问题的方式和应用场景有所不同。工厂模式主要关注对象的创建，而策略模式关注算法或行为的封装和替换。理解这些相似之处和差异对于正确选择和应用这些模式至关重要。

5. 工厂模式与策略模式的区别

5.1 解决问题的目的不同

工厂模式和策略模式虽然都是设计模式，但它们解决的问题类型不同。

  • 工厂模式：主要解决对象创建的问题，特别是当对象的创建过程复杂或者需要根据不同的条件创建不同类型的对象时。它将对象的创建逻辑封装在工厂类中，使得客户端代码不需要知道具体的类是如何被实例化的。
  • 策略模式：主要解决算法或行为的选择问题，允许在运行时选择不同的算法或行为，而不需要修改使用算法的代码。它将算法或行为封装在策略类中，使得算法或行为可以独立于使用它们的客户端变化。

5.2 应用场景的差异

工厂模式和策略模式的应用场景也有所不同。

  • 工厂模式：适用于以下场景：

    • 创建对象的过程复杂，或者对象的创建依赖于多个条件。
    • 需要根据输入参数的不同创建不同的对象。
    • 需要隐藏对象创建的细节，使得客户端代码更加简洁。

  • 策略模式：适用于以下场景：

    • 需要在运行时选择不同的算法或行为。
    • 需要根据不同的条件或配置文件更换算法或行为。
    • 需要避免使用多重条件语句来选择算法或行为。

5.3 实现方式的不同

工厂模式和策略模式的实现方式也有所区别。

  • 工厂模式：

    • 简单工厂模式：通常由一个工厂类根据输入参数返回不同的实例。
    • 工厂方法模式：定义一个创建对象的接口，让子类决定实例化哪个类。
    • 抽象工厂模式：提供一个接口，用于创建一系列相关或相互依赖的对象。

  • 策略模式：

    • 定义一个策略接口，包含一个或多个算法的方法。
    • 实现具体的策略类，这些类实现策略接口，并提供算法的具体实现。
    • 创建一个上下文类，它包含一个对策略接口的引用，并定义了一个方法，该方法接受策略对象作为参数。

5.4 代码示例对比

以下是一个简单的工厂模式和策略模式的代码示例对比。

工厂模式示例：

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

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

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

// 工厂接口
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 Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product product = factory.createProduct();
        product.use();
    }
}

策略模式示例：

// 策略接口
interface Strategy {
    void execute();
}

// 具体策略A
class ConcreteStrategyA implements Strategy {
    public void execute() {
        System.out.println("Executing ConcreteStrategyA");
    }
}

// 具体策略B
class ConcreteStrategyB implements Strategy {
    public void execute() {
        System.out.println("Executing ConcreteStrategyB");
    }
}

// 上下文类
class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteStrategyA());
        context.executeStrategy();

        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy();
    }
}

通过这些示例，我们可以看到工厂模式和策略模式在实现方式上的差异。工厂模式关注对象的创建，而策略模式关注算法或行为的选择和替换。

6. 工厂模式的应用案例分析

6.1 简单工厂模式案例

场景描述：假设我们有一个日志记录系统，需要根据不同的日志级别（如INFO, DEBUG, ERROR）来创建不同的日志记录器。

代码示例：

// 日志级别枚举
enum LogLevel {
    INFO, DEBUG, ERROR
}

// 日志记录器接口
interface Logger {
    void log(String message);
}

// INFO日志记录器
class InfoLogger implements Logger {
    public void log(String message) {
        System.out.println("INFO: " + message);
    }
}

// DEBUG日志记录器
class DebugLogger implements Logger {
    public void log(String message) {
        System.out.println("DEBUG: " + message);
    }
}

// ERROR日志记录器
class ErrorLogger implements Logger {
    public void log(String message) {
        System.out.println("ERROR: " + message);
    }
}

// 简单工厂
class LoggerFactory {
    public static Logger getLogger(LogLevel level) {
        switch (level) {
            case INFO:
                return new InfoLogger();
            case DEBUG:
                return new DebugLogger();
            case ERROR:
                return new ErrorLogger();
            default:
                throw new IllegalArgumentException("Invalid log level");
        }
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        LogLevel level = LogLevel.INFO;
        Logger logger = LoggerFactory.getLogger(level);
        logger.log("This is an info message.");
    }
}

6.2 工厂方法模式案例

场景描述：假设我们有一个图形编辑器，需要根据不同的图形类型（如圆形、矩形）来创建不同的图形对象。

代码示例：

// 图形接口
interface Shape {
    void draw();
}

// 圆形类
class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

// 矩形类
class Rectangle implements Shape {
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

// 工厂接口
interface ShapeFactory {
    Shape createShape();
}

// 圆形工厂
class CircleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Circle();
    }
}

// 矩形工厂
class RectangleFactory implements ShapeFactory {
    public Shape createShape() {
        return new Rectangle();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ShapeFactory factory = new CircleFactory();
        Shape shape = factory.createShape();
        shape.draw();

        factory = new RectangleFactory();
        shape = factory.createShape();
        shape.draw();
    }
}

6.3 抽象工厂模式案例

场景描述：假设我们有一个颜色主题系统，需要根据不同的主题（如亮色、暗色）来创建一系列的颜色对象。

代码示例：

// 颜色接口
interface Color {
    void fill();
}

// 红色类
class Red implements Color {
    public void fill() {
        System.out.println("Filling with red color");
    }
}

// 蓝色类
class Blue implements Color {
    public void fill() {
        System.out.println("Filling with blue color");
    }
}

// 亮色主题
interface LightColor extends Color {}

// 暗色主题
interface DarkColor extends Color {}

// 抽象工厂接口
interface ColorFactory {
    Color getColor(String color);
}

// 亮色工厂
class LightColorFactory implements ColorFactory {
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("BLUE")) {
            return new Blue();
        }
        return null;
    }
}

// 暗色工厂
class DarkColorFactory implements ColorFactory {
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        // 暗色主题下的颜色实现
        return null;
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ColorFactory factory = new LightColorFactory();
        Color color = factory.getColor("RED");
        if (color != null) {
            color.fill();
        }
    }
}

在这些案例中，我们可以看到工厂模式如何根据不同的需求和场景来创建对象。简单工厂模式适用于对象创建逻辑相对简单的情况；工厂方法模式适用于对象创建逻辑分散在不同的工厂类中，每个工厂类负责创建特定的产品；抽象工厂模式适用于需要创建一系列相关或相互依赖的对象的情况。

7. 策略模式的应用案例分析

7.1 策略模式在排序算法中的应用

场景描述：在数据处理和算法设计中，排序是常见的任务。不同的数据集和需求可能需要不同的排序算法。使用策略模式可以动态选择最合适的排序算法。

代码示例：

// 排序策略接口
interface SortStrategy {
    void sort(int[] numbers);
}

// 冒泡排序策略
class BubbleSortStrategy implements SortStrategy {
    public void sort(int[] numbers) {
        // 实现冒泡排序算法
        System.out.println("Sorting using Bubble Sort");
    }
}

// 快速排序策略
class QuickSortStrategy implements SortStrategy {
    public void sort(int[] numbers) {
        // 实现快速排序算法
        System.out.println("Sorting using Quick Sort");
    }
}

// 排序上下文
class SortContext {
    private SortStrategy strategy;

    public SortContext(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(SortStrategy strategy) {
        this.strategy = strategy;
    }

    public void performSort(int[] numbers) {
        strategy.sort(numbers);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 8, 4, 2};

        SortContext context = new SortContext(new BubbleSortStrategy());
        context.performSort(numbers);

        context.setStrategy(new QuickSortStrategy());
        context.performSort(numbers);
    }
}

在这个例子中，SortStrategy 是一个策略接口，定义了 sort 方法。BubbleSortStrategy 和 QuickSortStrategy 是具体的策略类，实现了不同的排序算法。SortContext 是上下文类，它使用策略接口来引用具体的排序策略，并执行排序操作。客户端可以根据需要动态更换排序策略。

7.2 策略模式在支付系统中的应用

场景描述：在电子商务平台中，支付方式的多样性是一个重要特性。策略模式可以用来设计一个灵活的支付系统，允许用户在不同的支付方式之间自由切换。

代码示例：

// 支付策略接口
interface PaymentStrategy {
    void pay(int amount);
}

// 信用卡支付策略
class CreditCardPaymentStrategy implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using Credit Card.");
    }
}

// 支付宝支付策略
class AlipayPaymentStrategy implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using Alipay.");
    }
}

// 微信支付策略
class WeChatPayPaymentStrategy implements PaymentStrategy {
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using WeChat Pay.");
    }
}

// 支付上下文
class PaymentContext {
    private PaymentStrategy strategy;

    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }

    public void executePayment(int amount) {
        strategy.pay(amount);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        int amount = 100;

        PaymentContext context = new PaymentContext(new CreditCardPaymentStrategy());
        context.executePayment(amount);

        context.setStrategy(new AlipayPaymentStrategy());
        context.executePayment(amount);

        context.setStrategy(new WeChatPayPaymentStrategy());
        context.executePayment(amount);
    }
}

在这个例子中，PaymentStrategy 是一个策略接口，定义了 pay 方法。CreditCardPaymentStrategy、AlipayPaymentStrategy 和 WeChatPayPaymentStrategy 是具体的策略类，实现了不同的支付方式。PaymentContext 是上下文类，它使用策略接口来引用具体的支付策略，并执行支付操作。客户端可以根据用户的支付偏好动态更换支付策略。

通过这些案例，我们可以看到策略模式如何提供灵活性和可扩展性，允许在运行时根据不同的需求选择和更换算法或行为。

8. 工厂模式与策略模式的选择指南

8.1 根据需求选择合适的模式

选择工厂模式还是策略模式取决于系统设计的需求和目标。

  • 当关注点在于对象的创建时，选择工厂模式。这包括以下情况：

    • 需要创建的对象类型很多，且这些对象共享相同的接口。
    • 对象的创建过程复杂，或者创建逻辑需要被隐藏。
    • 需要在不指定具体类的情况下，通过配置或参数来创建对象。

  • 当关注点在于行为或算法的选择时，选择策略模式。这包括以下情况：

    • 需要在运行时根据不同的条件选择不同的算法或行为。
    • 算法或行为可能经常变化，或者需要易于扩展。
    • 需要避免使用复杂的条件语句来选择不同的算法或行为。

8.2 模式的优缺点分析

工厂模式

优点：

  • 封装性：对象的创建逻辑被封装在工厂类中，客户端不需要知道具体的实现细节。
  • 扩展性：新增产品时，只需新增相应的具体产品类和工厂类，无需修改现有代码。
  • 解耦：客户端代码与对象创建逻辑解耦，提高了代码的可维护性。

缺点：

  • 系统复杂性：随着产品类的增加，工厂类可能会变得复杂，难以维护。
  • 增加系统对象：增加了额外的工厂类，可能会导致系统中对象数量增加。
策略模式

优点：

  • 灵活性：算法或行为可以在运行时更换，提高了系统的灵活性。
  • 扩展性：新增策略时，只需新增具体的策略类，无需修改现有代码。
  • 避免多重条件：避免了在客户端代码中使用复杂的条件判断语句。

缺点：

  • 客户端选择策略：客户端需要知道所有可用的策略，这可能会增加客户端的复杂性。
  • 策略类数量：随着策略的增加，系统中的策略类数量也会增加。

在选择工厂模式或策略模式时，需要根据具体的设计目标和需求来权衡。通常，如果系统需要灵活地创建对象，那么工厂模式是一个好的选择。如果系统需要灵活地更换算法或行为，那么策略模式可能更合适。在某些情况下，这两种模式也可以结合使用，以达到更好的设计效果。

9. 结论

9.1 总结

在本文中，我们深入探讨了工厂模式和策略模式这两种设计模式。通过对比分析，我们了解到它们各自的特点和适用场景：

  • 工厂模式专注于对象的创建，它通过一个工厂类来封装对象的创建过程，使得系统在对象创建方面的扩展变得更加容易。工厂模式包括简单工厂模式、工厂方法模式和抽象工厂模式，每种模式适用于不同的场景。

  • 策略模式则关注算法或行为的封装和替换，它允许在运行时根据不同的需求选择不同的算法或行为，从而提高了系统的灵活性和可扩展性。

尽管这两种模式都旨在提高代码的灵活性和可维护性，但它们解决问题的侧重点不同。工厂模式主要用于解决对象创建的问题，而策略模式则用于解决算法或行为的选择问题。

9.2 未来研究方向

随着软件工程领域的不断发展，工厂模式和策略模式的应用和研究也在不断扩展。未来的研究方向可能包括：

  1. 模式的组合使用：研究如何更有效地结合工厂模式和策略模式，以及其他设计模式，以解决更复杂的软件设计问题。

  2. 模式在不同编程语言中的实现：探索不同编程语言（如函数式编程语言）中工厂模式和策略模式的实现方式和最佳实践。

  3. 模式在微服务架构中的应用：研究在微服务架构中如何应用工厂模式和策略模式，以提高服务的灵活性和可维护性。

  4. 模式在特定领域的应用案例研究：深入分析工厂模式和策略模式在特定领域（如人工智能、大数据、物联网等）的应用案例，总结最佳实践。

  5. 模式的自动化检测工具：开发工具或插件，帮助开发者自动识别代码中的模式使用情况，以及潜在的改进点。

  6. 模式的教育和普及：通过教育和培训，提高开发者对设计模式的认识和应用能力，特别是在初学者和非专业开发者中推广。

通过这些研究方向的探索，我们可以更好地理解和应用工厂模式和策略模式，从而设计出更加健壮、灵活和可维护的软件系统。

10. 附录

10.1 术语解释

  • 设计模式（Design Pattern）：在软件工程中，设计模式是对软件设计中常见问题的一种解决方案。它们像模板一样，可以被重复使用，以解决特定问题。

  • 创建型模式（Creational Pattern）：这类设计模式提供了创建对象的最佳方式，而不是直接使用new运算符实例化对象。它们帮助系统在创建对象时更加灵活。

  • 工厂模式（Factory Pattern）：一种创建型设计模式，用于处理对象创建的问题，它通过一个工厂类来封装对象的创建过程。

  • 简单工厂模式（Simple Factory Pattern）：一个工厂类根据输入参数，动态决定创建出哪一种产品类的实例。

  • 工厂方法模式（Factory Method Pattern）：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。

  • 抽象工厂模式（Abstract Factory Pattern）：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。

  • 行为型模式（Behavioral Pattern）：这类设计模式特别关注对象之间的通信。

  • 策略模式（Strategy Pattern）：一种行为型设计模式，允许在运行时选择算法或行为。

  • 上下文（Context）：在策略模式中，上下文是一个使用策略接口的类，它维护一个对策略对象的引用。

  • 策略（Strategy）：在策略模式中，策略是一个接口，定义了一系列算法或行为。

  • 具体策略（Concrete Strategy）：在策略模式中，具体策略是实现策略接口的具体算法或行为。

10.2 代码示例

工厂模式代码示例：

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

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

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

// 工厂接口
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 Client {
    public static void main(String[] args) {
        Factory factory = new ConcreteFactoryA();
        Product product = factory.createProduct();
        product.use();
    }
}

策略模式代码示例：

// 策略接口
interface Strategy {
    void execute();
}

// 具体策略A
class ConcreteStrategyA implements Strategy {
    public void execute() {
        System.out.println("Executing ConcreteStrategyA");
    }
}

// 具体策略B
class ConcreteStrategyB implements Strategy {
    public void execute() {
        System.out.println("Executing ConcreteStrategyB");
    }
}

// 上下文类
class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Context context = new Context(new ConcreteStrategyA());
        context.executeStrategy();

        context.setStrategy(new ConcreteStrategyB());
        context.executeStrategy();
    }
}

这些代码示例提供了工厂模式和策略模式的基本实现框架，展示了如何根据不同的需求选择合适的设计模式来解决问题。通过这些示例，读者可以更好地理解每种模式的工作原理和应用场景。

标签：策略,区别,void,模式,工厂,算法,public
From： https://blog.csdn.net/molangmolang/article/details/141506498

相关文章

  • 【设计模式基础版】观察者模式
    观察者模式（ObserverPattern）是一种**行为型设计模式**，它定义了一种一对多的依赖关系，当一个对象的状态发生改变时，其所有依赖者（观察者）都会收到通知并自动更新。观察者模式常用于需要自动通知多个对象状态变化的场景，例如事件处理系统、订阅-发布系统等。所以也被称作“发布-订......
  • 设计模式——六大原则
    一、六大设计原则1.单一职责原则：应该有且仅有一个原因引起类的变更2.里氏替换原则：子类可替换父类。a)子类必须完全实现父类的方法b)子类可以有自己的个性c)子类实现父类方法时，入参可放大d)子类实现父类方法时，输出参数可缩小3.依赖倒置原则：高层模块......
  • 二十三种模式之抽象工厂模式
    1.设计模式的分类创建型模式(五种)：工厂方法模式、单例模式、抽象工厂模式、原型模式、建造者模式。结构型模式(七种)：适配器模式、代理模式、装饰器模式、桥接模式、外观模式、享元模式、组合模式。行为型模式(十一种)：状态模式、模板方法模式、访问者模式、迭代子模式、责任链......
  • Java行为型设计模式-访问者模式（含二叉树场景示例）
    1.访问者模式简介访问者模式（VisitorPattern）是一种行为型设计模式，其主要目的是将数据结构与数据操作解耦。用于将数据结构和在数据结构上的操作分离开来。‌这种模式允许在不修改数据结构的情况下，定义新的操作。2.访问者模式角色访问者模式的主要角色包括：2.1抽象访问......
  • 反汇编和汇编的区别 怎么用汇编让C语言更小
    在计算机编程的世界中，反汇编和汇编这两个概念往往令人感到深奥而神秘。究竟反汇编和汇编之间有何异同?这是程序员们经常探讨的话题。汇编语言作为一种底层编程语言，与计算机硬件密切相关，而反汇编则是将机器码还原为可读的汇编语言的过程。本文将深入研究反汇编和汇编的区别，帮助......
  • 汇编和反汇编的区别
    在linux系统下编写如下代码： 通过指令：gcc-Smain.c将生成main.s文件即就汇编文件（在上篇博客我已提到过）。 通过指令：gcc-cmain.c生成main.o（二进制文件）再通过指令：objdump-dmain.o生成反汇编 反汇编是基于机器代码的文件中的字节序列来确定汇编的代码。左边为字节......
  • 在C#中应用命令模式：设计和实现的最佳实践
    在C#中应用命令模式：设计和实现的最佳实践引言在软件设计中，设计模式是解决常见问题的通用解决方案。命令模式（CommandPattern）是行为型设计模式之一，它将请求或操作封装为对象，从而使得你可以用不同的请求对客户端进行参数化，队列请求或记录请求日志，以及支持可撤销的操作。在C#......
  • ZBlog强制开启 Debug 调试模式
    常规开启调试模式是在后台设置中进行，在后台设置的全局设置里打开“调试模式”并保存即可。如果网站程序出错，不能进入后台进行设置，那么在1.7.3及更高版本可以在这样设置：使用空间面板的文件管理或者FTP修改文件：path/zb_users/c_option.php；'ZC_DEBUG_MODE'=>true,//开启Deb......
  • 基于开源 AI 智能名片链动 2+1 模式微信拓客小程序的会员推荐酬谢策略
    摘要：本文旨在探讨在当前数字化营销环境下，如何利用开源AI智能名片链动2+1模式微信拓客小程序，有效地酬谢老会员的推荐行为，以实现门店的业务增长和客户拓展。通过分析老会员推荐的重要性，结合积分酬谢方式以及与“三级分销”概念的区别，提出了一套切实可行的酬谢策略，为门店的经......
  • 设计模式篇（DesignPattern - 前置知识 & 七大原则）（持续更新调整）
    目录前置知识一、什么是设计模式二、设计模式的目的七大原则原则一：单一职责原则一、案例一：交通工具问题1.问题分析2.解决思路2.1类级别单一职责2.2方法级别单一职责3.知识小结二、案例二：待更新原则二：接口隔离原则一、案例一：大接口拆分小接口1.问题分析2.......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99