如何选择工厂模式或策略模式：Java设计模式实践指南

目录

1. 引言

   • 1.1 设计模式的重要性
   • 1.2 工厂模式与策略模式的概述

2. 工厂模式

   • 2.1 工厂模式简介
   • 2.2 工厂模式的分类
     • 2.2.1 简单工厂模式
     • 2.2.2 工厂方法模式
     • 2.2.3 抽象工厂模式
   • 2.3 工厂模式的适用场景
   • 2.4 工厂模式的优缺点
   • 2.5 工厂模式的Java实现
     • 2.5.1 简单工厂模式的实现
     • 2.5.2 工厂方法模式的实现
     • 2.5.3 抽象工厂模式的实现

3. 策略模式

   • 3.1 策略模式简介
   • 3.2 策略模式的应用场景
   • 3.3 策略模式的优缺点
   • 3.4 策略模式的Java实现

1. 引言

1.1 设计模式的重要性

在软件开发过程中，设计模式是一种成熟的解决方案，用来解决特定情境下的通用问题。对于Java开发者而言，掌握设计模式不仅能提高代码的可维护性和可扩展性，还能在设计系统架构时提供更优雅和高效的解决方案。工厂模式和策略模式是两种常用的设计模式，分别在对象创建和行为变化方面提供了有效的解决方案。

1.2 工厂模式与策略模式的概述

工厂模式主要解决的是“对象创建”的问题，而策略模式则专注于“行为变化”的管理。两者虽然在结构和用途上有很大的不同，但在一些复杂的设计中，常常会有交叉和组合使用的情况。因此，理解它们的区别和各自的适用场景，对于构建灵活和可维护的系统至关重要。

---

2. 工厂模式

2.1 工厂模式简介

工厂模式是一种创建型设计模式，通过将对象的实例化过程封装起来，使得客户端不需要直接依赖具体类，从而实现对象创建过程的灵活性和扩展性。它主要包含三种不同的实现形式：简单工厂模式、工厂方法模式和抽象工厂模式。

2.2 工厂模式的分类

2.2.1 简单工厂模式

简单工厂模式是一种最基础的工厂模式实现，通常被称为静态工厂方法。这种模式通过一个工厂类，根据输入条件来创建并返回不同类型的实例。简单工厂模式的优点在于易于理解和实现，但它违反了开闭原则，因为添加新产品时需要修改工厂类。

2.2.2 工厂方法模式

工厂方法模式通过定义一个接口或抽象类来创建对象，具体的对象创建由子类来实现。这样做的好处是遵循了开闭原则，使得系统更容易扩展。每个具体的工厂类都负责创建一个特定的产品实例，这样当需要增加新产品时，只需添加新的工厂类即可。

2.2.3 抽象工厂模式

抽象工厂模式扩展了工厂方法模式，它不仅可以创建一类产品，还可以创建一组相关或依赖的产品。通过定义多个工厂接口，抽象工厂模式可以生成一系列相关联的对象实例，并确保它们之间的相互兼容性。这个模式特别适合于需要生成一系列相关产品的系统。

2.3 工厂模式的适用场景

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

• 需要创建复杂对象时，且这些对象有复杂的构建过程。
• 系统中对象的创建需要封装在一个类中，以避免直接暴露对象的实例化细节。
• 在系统中创建多种类型的相关对象，并希望确保它们之间的一致性。

2.4 工厂模式的优缺点

优点：

• 提高了系统的灵活性，遵循了开闭原则。
• 将对象的创建逻辑集中在一处，便于管理和修改。
• 支持产品族的概念，有助于构建一系列相关对象。

缺点：

• 增加了系统的复杂度，尤其是在工厂方法模式和抽象工厂模式中。
• 当产品种类或创建过程较为简单时，使用工厂模式可能显得冗余。

2.5 工厂模式的Java实现

2.5.1 简单工厂模式的实现

public class SimpleFactory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        } else {
            throw new IllegalArgumentException("Unknown product type");
        }
    }
}

2.5.2 工厂方法模式的实现

public interface Factory {
    Product createProduct();
}

public class FactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class FactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

2.5.3 抽象工厂模式的实现

public interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

public class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA1();
    }

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

public class ConcreteFactory2 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ProductA2();
    }

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

---

3. 策略模式

3.1 策略模式简介

策略模式是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使得它们可以互换使用。策略模式使得算法的变化不会影响到使用算法的客户。通过这种方式，可以在运行时动态选择和改变算法。

3.2 策略模式的应用场景

策略模式非常适用于以下情况：

• 多个类仅在行为上有所不同，可以使用策略模式来动态选择行为。
• 需要在运行时根据不同的条件选择不同的算法。
• 避免使用条件语句或分支语句来选择不同的行为或算法。

3.3 策略模式的优缺点

优点：

• 提高了算法的灵活性，允许在运行时改变算法。
• 避免了大量的条件语句，使代码更加清晰。
• 提供了算法的封装和独立扩展。

缺点：

• 增加了系统的复杂性，特别是在有许多策略时。
• 客户端必须了解策略之间的区别，以便正确选择策略。

3.4 策略模式的Java实现

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy A");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        System.out.println("Executing strategy B");
    }
}

public 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();
    }
}

---