Java设计模式：工厂模式与策略模式的实现与应用

最新推荐文章于 2024-08-24 10:19:32 发布
最新推荐文章于 2024-08-24 10:19:32 发布
阅读量686 收藏 11
点赞数 3
文章标签： java 设计模式 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41859354/article/details/141201078
版权

Java设计模式：工厂模式与策略模式的实现与应用

设计模式是软件开发中的最佳实践，它提供了一种在软件设计中解决特定问题的标准化方法。工厂模式和策略模式是两种常见的设计模式，它们在不同的场景下解决不同的问题。本文将深入探讨这两种模式的概念、实现及应用。

一、工厂模式

1.1 工厂模式概述

工厂模式（Factory Pattern）是一种创建对象的设计模式，它提供了一种创建对象的接口，但由子类决定实例化哪个类。工厂模式将对象的创建与使用分离，提高了系统的灵活性和可维护性。

1.2 工厂模式的类型

工厂模式主要有三种类型：

  1. 简单工厂模式（Simple Factory Pattern）：由一个工厂类决定实例化哪一个产品类。简单工厂模式的核心是一个工厂类，它根据输入的信息返回不同的产品实例。

  2. 工厂方法模式（Factory Method Pattern）：定义了一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法模式将工厂类的创建工作交给子类，实现了类的解耦。

  3. 抽象工厂模式（Abstract Factory Pattern）：提供一个创建一系列相关或相互依赖对象的接口，而无需指定具体类。抽象工厂模式通常用来创建一组相关的产品对象。

1.3 简单工厂模式的实现

简单工厂模式的实现通常包括一个工厂类和多个产品类。下面是一个简单工厂模式的示例：

// 产品接口
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 ProductFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ProductA();
        } else if ("B".equals(type)) {
            return new ProductB();
        }
        throw new IllegalArgumentException("Unknown product type");
    }
}

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

在这个示例中，ProductFactory 类根据传入的类型创建不同的 Product 实例。客户端代码不需要了解具体的产品类，只需要调用工厂方法即可。

1.4 工厂方法模式的实现

工厂方法模式的实现包括一个抽象工厂类和多个具体工厂类。下面是一个工厂方法模式的示例：

// 产品接口
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 ProductFactory {
    public abstract Product createProduct();
}

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

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

// 客户端代码
public class Client {
    public static void main(String[] args) {
        ProductFactory factory = new ProductAFactory();
        Product product = factory.createProduct();
        product.use();
    }
}

在这个示例中，ProductFactory 是一个抽象工厂类，具体的工厂子类（ProductAFactory 和 ProductBFactory）实现了创建不同产品的方法。客户端代码可以通过不同的工厂实例创建产品。

1.5 抽象工厂模式的实现

抽象工厂模式的实现包括一个抽象工厂接口和多个具体工厂类，同时还包含一组产品接口和具体产品类。下面是一个抽象工厂模式的示例：

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

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

// 具体产品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 use() {
        System.out.println("Using Product B1");
    }
}

// 具体产品B2
public class ProductB2 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 ProductA1();
    }

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

// 具体工厂2
public class ConcreteFactory2 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 factory = new ConcreteFactory1();
        ProductA productA = factory.createProductA();
        ProductB productB = factory.createProductB();
        productA.use();
        productB.use();
    }
}

在这个示例中，AbstractFactory 提供了创建产品A和产品B的方法。ConcreteFactory1 和 ConcreteFactory2 实现了这些方法，创建不同的产品组合。客户端代码使用具体工厂实例创建一组相关产品。

二、策略模式

2.1 策略模式概述

策略模式（Strategy Pattern）是一种行为型设计模式，它定义了一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。

2.2 策略模式的实现

策略模式主要包括三个角色：

  1. 上下文（Context）：持有一个策略对象，并调用其算法。
  2. 策略接口（Strategy）：定义所有支持的算法接口。
  3. 具体策略（ConcreteStrategy）：实现具体的算法。

下面是一个策略模式的示例：

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

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

// 具体策略B
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();
    }
}

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

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

在这个示例中，Strategy 是一个策略接口，ConcreteStrategyA 和 ConcreteStrategyB 实现了具体的算法。Context 类持有一个策略对象，并调用其 execute 方法。客户端代码可以动态改变策略，执行不同的算法。

2.3 策略模式的应用场景

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

  1. 算法的多种变体：当一个类有多个算法时，可以使用策略模式将这些算法封装起来，并在运行时选择合适的算法。
  2. 算法的独立变化：当一个算法的变化独立于使用它的客户端时，可以使用策略模式。
  3. 避免使用多重条件语句：当系统需要使用大量的条件语句来选择算法时，策略模式可以减少条件判断，提高代码的可维护性。

三、工厂模式与策略模式的比较与应用

3.1 工厂模式与策略模式的比较
  1. **目的

不同**：

  • 工厂模式主要关注于对象的创建过程。
  • 策略模式主要关注于对象的行为或算法。

  1. 适用场景不同：

    • 工厂模式适用于需要创建多个类的对象时，通过工厂类来管理对象的创建。
    • 策略模式适用于需要在运行时选择算法或行为时，将算法封装在不同的策略类中。

  2. 结构不同：

    • 工厂模式通过工厂类或工厂方法来实现对象的创建。
    • 策略模式通过策略接口和具体策略类来实现算法的封装和选择。
3.2 工厂模式与策略模式的联合应用

在实际开发中，工厂模式和策略模式可以联合使用。例如，一个工厂类可以创建策略对象，而策略对象可以提供不同的算法。在这种情况下，工厂模式负责创建策略对象，策略模式负责封装算法。

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

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

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

// 策略工厂
public class StrategyFactory {
    public static Strategy createStrategy(String type) {
        if ("A".equals(type)) {
            return new ConcreteStrategyA();
        } else if ("B".equals(type)) {
            return new ConcreteStrategyB();
        }
        throw new IllegalArgumentException("Unknown strategy type");
    }
}

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

    public Context(String strategyType) {
        this.strategy = StrategyFactory.createStrategy(strategyType);
    }

    public void setStrategy(String strategyType) {
        this.strategy = StrategyFactory.createStrategy(strategyType);
    }

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

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

        context.setStrategy("B");
        context.executeStrategy();
    }
}

在这个示例中，StrategyFactory 工厂类负责创建具体的策略对象，而 Context 类使用这些策略对象。客户端代码通过工厂类创建策略，并通过上下文类执行策略。

四、总结

工厂模式和策略模式是两种常见的设计模式，它们在不同的场景下解决不同的问题。工厂模式主要关注于对象的创建，通过工厂类将对象的创建与使用分离。而策略模式主要关注于算法的封装，通过策略接口和具体策略类将算法独立于客户端。

在实际开发中，了解和掌握这些设计模式的应用场景和实现方式可以帮助提高系统的灵活性和可维护性。工厂模式和策略模式可以联合使用，通过工厂模式创建策略对象，通过策略模式封装算法，满足不同的需求和场景。

范范0825
关注
Java的设计模式和应用场景以及代码实例
10-14
以下是Java中常见的设计模式和应用场景，以及实例代码
Java设计模式：工厂模式——图文+代码示例（通俗易懂）
12-21
Java设计模式中的工厂模式是一种创建型设计模式，其主要目的是为了解耦对象的创建与使用。工厂模式通过提供一个统一的接口或类来创建对象，使得客户端代码无需直接实例化对象，而是通过调用工厂方法来获取所需的对象...
策略模式 + 工厂模式
社畜程序员的无聊博客
01-29 7229
该模式定义了一些里而算法, 并将每个算法封装起来, 是他们可以互相替换, 且算法的变化不会影响使用算法的客户. 策略模式属于对象行为模式, 它通过对算法进行封装, 把使用该算法的责任和算法的实现分割开来, 并委派给不同的对象对这些算法进行管理优点策略类之间可以自由切换 – 由于策略类都是先同一个接口, 所以使他们之间可以自由切换易于扩展 – 增加一个新的策略只需要添加一个具体的策略类即可, 基本不需要改变原有的代码, 符合"开闭原则"某特定场景下相对。
工厂模式和策略模式的综合使用
热门推荐
张彦峰的博客
06-24 2万+
其实在很多的开发设计中，将工厂模式和策略模式的综合使用的案例是很多的，而且解决的实际问题也一样很多，本次对基本的简单工厂模式和策略模式做简单介绍，重点放在两者结合后的具体应用上做分析和讲解。
java 工厂模式实现_Java实现简单工厂模式
weixin_35825868的博客
02-21 107
昨天看了一下设计模式，复习了一下简单工厂模式，做个笔记，浅淡一下我对简单工厂模式的理解。书上使用的是C#，因为我所学的是Java，所以本人就用Java实现了一遍。如果有讲的不对的地方，希望能够指出来。简单工厂设计模式可以简单地理解为，你拿着一个空口袋去水果店买水果，你把空袋子给水果店老板，然后对老板讲我需要一袋子的柚子，十分钟以后。老板递给你一袋子柚子。你不需要知道他们是怎么区分柚子和橘子，又是怎...
Java常见设计模式应用场景
starryocean
03-08 2448
1、抽象工厂应用场景：封装变化点。创建一系列相互依赖的对象。在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作;同时由于需求的变化，往往存在更多系列对象的创建工作。如何应对这各变化如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合。public abstract Class AbstractFactory{    //创
【Java】Java 设计模式之工厂模式与策略模式
最新发布
Young_Pro的博客
08-24 829
Java设计模式是软件工程中一系列被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结，它们代表了最佳的实践，帮助开发者解决在软件设计过程中遇到的各种问题。这些模式可以根据其用途分为三大类：创建型、结构型和行为型，每种模式都有其特定的应用场景和解决的问题，例如单例模式用于确保一个类只有一个实例，工厂模式用于创建对象而不暴露创建逻辑，观察者模式用于定义对象间的一对多依赖关系，使得当一个对象改变状态时，所有依赖于它的对象都会得到通知并自动更新。掌握这些设计模式有助于提高代码的可读性、可维护性和可扩展性。
掌握Spring设计模式：Java工程师必备指南
12-13
通过理解和熟练运用这些设计模式，Java工程师不仅可以更好地理解Spring框架的工作原理，还能提升自己的代码设计水平，编写出更符合软件工程原则、易于维护和扩展的代码。在实际开发中，应注重模式的适用场景，避免...
重学java的设计模式
05-09
Java作为一门广泛应用的开发语言，其设计模式的应用对于提高代码质量、可维护性和可扩展性至关重要。本文将着重探讨创建型模式、结构型模式和行为模式这三大类设计模式，并结合六项设计原则进行深入解析。 首先，...
Java设计模式综合应用场景
06-23
Java设计模式综合应用场景，实验报告内含核心代码，三种以上设计模式综合使用场景，图形界面 本资源已经失效，新链接如下：https://download.csdn.net/download/dtlscsl/11247009
Java设计模式之工厂方法的工厂方法实现的源码
06-15
在软件开发中，设计模式是一种解决常见问题的模板或最佳实践，它们被广泛应用于构建可扩展、可维护的代码库。工厂方法模式是设计模式中的一员，属于创建型模式，它提供了一种创建对象的最佳方式。这个Java源码示例是...
Java设计模式之工厂方法的ifelse实现的源码
06-15
总的来说，"Java设计模式之工厂方法的ifelse实现"展示了如何在Java中使用设计模式解决特定问题，即在商场促销活动中创建和管理各种策略对象。通过对源码的深入理解，我们可以学习到如何运用工厂方法模式来提高代码的...
Java常用设计模式（工厂，策略，责任链）
a1783760364的博客
03-14 2290
定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法模式把类实例化的过程推迟到子类。最主要的就是将实例化代码交给子类，即：分店思想，每一个分店有不同的店铺逻辑（每个分店有不同的菜单）
java设计模式及应用场景
12-18 387
掌握常用的几种（最起码单例模式、工厂模式），了解其他的设计模式即可，做到手里有粮，心里不慌。首先，掌握每种模式的定义及使用场景。其次，掌握一个形象的例子，简单的过一遍代码。学习设计模式的真正目的：编程时，有意识地面向接口编程，多用封装、继承、组合、多态等OOP思想，而不仅仅是死记几类设计模式。 ...
Java开源框架中的设计模式以及应用场景
程序员高级码农的博客
02-29 2382
设计模式是软件设计中常见问题的典型解决方案，你可以通过对其进行定制来解决代码中的特定设计问题。关于设计模式，网上有很多讲解。但大部分都是Demo示例，看完有可能还是不知道怎么用。本文笔者将从设计模式入手，看一看在优秀的Java框架/中间件产品中，不同的设计模式应用场景在哪里。
Java中的设计模式及其应用场景解析
聚娃科技开发者博客
07-05 218
本文介绍了Java中常见的设计模式及其应用场景，包括创建型、结构型和行为型设计模式，希望能够帮助读者在实际开发中灵活运用这些模式，提高代码的质量和可维护性。设计模式是软件开发中常用的解决方案模板，能够帮助开发人员解决常见的设计问题并提高代码的可重用性、灵活性和可维护性。大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！观察者模式定义了对象之间的一对多依赖关系，当一个对象状态发生改变时，所有依赖它的对象都会得到通知并自动更新。
java设计模式 应用_Java 设计模式之组合模式及应用场景
weixin_33335851的博客
02-12 131
组合模式，就是在一个对象中包含其他对象，这些被包含的对象可能是终点对象(不再包含别的对象)，也有可能是非终点对象(其内部还包含其他对象，或叫组对象)，我们将对象称为节点，即一个根节点包含许多子节点，这些子节点有的不再包含子节点，而有的仍然包含子节点，以此类推。很明显，这是树形结构，终结点叫叶子节点，非终节点(组节点)叫树枝节点，第一个节点叫根节点。同时也类似于文件目录的结构形式：文件可称之为终节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值