小唐说设计模式————策略模式篇

最新推荐文章于 2024-09-25 23:08:45 发布
最新推荐文章于 2024-09-25 23:08:45 发布
阅读量138 收藏
点赞数 1
分类专栏： Java 设计模式 文章标签： 计算机 设计模式 java 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38154018/article/details/99343323
版权

策略模式适用于什么样子的场景呢？

    当我们的代码中出现了一连串的if…else…或者是switch…case…语句时，我们的代码体就会很长很臃肿，阅读性大大下降，此时可采用策略模式进行重构。

原理

    策略模式利用的是面向对象语言的三个特性，尤其是继承和多态。首先让多个类继承同一个抽象的父类或者是实现一个接口，在抽象类或者接口中声明我们要实现的抽象方法，在子类或者实现类中写出不同的方法实现。根据多态性，创建一个父类类型的引用，让其指向子类的对象，让根据对象的不同，执行各个同名但不同体的方法。

示例讲解

    以一个在线租赁商店demo为例：

    影片类，具有标题，价格码（对应的是影片的类型）：

public class Movie {
    public static final int CHILDRENS = 2;
    public static final int REGULAR = 0;
    public static final int NEW_RELEASE = 1;

    private String title;
    private int priceCode;

    public Movie(String title, int priceCode) {
        this.title = title;
        this.priceCode = priceCode;
    }

    public int getPriceCode() {
        return priceCode;
    }

    public void setPriceCode(int priceCode) {
        this.priceCode = priceCode;
    }

    public String getTitle() {
        return title;
    }
}

    租赁单类，包含一部电影和租赁的日期，同时还包含一个计算租赁金的方法：

public class Rental {
    private Movie movie;
    private int dayRented;

    public Rental(Movie movie, int dayRented) {
        this.movie = movie;
        this.dayRented = dayRented;
    }

    public Movie getMovie() {
        return movie;
    }

    public int getDayRented() {
        return dayRented;
    }

    public double getAmount(){
        double thisAmount = 0d;
        switch (movie.getPriceCode()) {
            case Movie.REGULAR:
                thisAmount += 2;
                if (this.getDayRented() > 2) {
                    thisAmount += (this.getDayRented() - 2) * 1.5;
                }
                break;
            case Movie.NEW_RELEASE:
                thisAmount += this.getDayRented() * 3;
                break;
            case Movie.CHILDRENS:
                thisAmount += 1.5;
                if (this.getDayRented() > 3) {
                    thisAmount += (this.getDayRented() - 3) * 1.5;
                }
                break;
        }
        return thisAmount;
    }
}

    顾客类，包含姓名、租赁的影片、总的租金以及积分点，和一个打印所有租赁信息的方法printStatement：

public class Customer {
    private String name;
    double totalAmount;
    int frequentRenterPoints;
    private List<Rental> rentals = new ArrayList<>();

    public Customer(String name) {
        this.name = name;
    }

    public void addRental(Rental arg) {
        rentals.add(arg);
    }

    public String getName() {
        return name;
    }

    public void printHeader(){
        String header = "Rental Record for " + getName() + "\n";
        System.out.print(header);
    }

    public void printBody(){
        String body = "";
        for (Rental each : this.rentals) {
            frequentRenterPoints++;
            if ((each.getMovie().getPriceCode() == Movie.NEW_RELEASE) && each.getDayRented() > 1) {
                frequentRenterPoints++;
            }
            body += "\t" + each.getMovie().getTitle() + "\t" + each.getAmount() + "\n";
            totalAmount += each.getAmount();
        }
        System.out.print(body);
    }

    public void printTail(){
        String tail = "";
        tail += "Amount owed is " + totalAmount + "\n";
        tail += "You earned " + frequentRenterPoints + " frequent renter points";
        System.out.print(tail);
    }

    public void printStatement(){
        printHeader();
        printBody();
        printTail();
    }
}

    主类，用于运行和测试：

public class Main {

    public static void main(String[] args) {
        Movie movie = new Movie("泰坦尼克号",Movie.REGULAR);
        Rental rental = new Rental(movie,3);
	    Customer customer = new Customer("Lily");
	    customer.addRental(rental);
	    customer.printStatement();
    }
}

    运行结果：

Rental Record for Lily
	泰坦尼克号	3.5
Amount owed is 3.5
You earned 1 frequent renter points

    代码其实不难理解（因为我觉得方法命名得还不错…），根据用户租赁的影片打印出用户消费的票据，每部影片的租金根据电影的标签和租赁时长计算，还可以累积积分点。

    一眼看过去其实还是有几个比较明显的bad code smell，我们暂且先选择性忽视它们…

    Rental类的getAmount()方法属于典型的长方法，又臭又长，大部分的原因是因为这个switch语句：

switch (movie.getPriceCode()) {
            case Movie.REGULAR:
                thisAmount += 2;
                if (this.getDayRented() > 2) {
                    thisAmount += (this.getDayRented() - 2) * 1.5;
                }
                break;
            case Movie.NEW_RELEASE:
                thisAmount += this.getDayRented() * 3;
                break;
            case Movie.CHILDRENS:
                thisAmount += 1.5;
                if (this.getDayRented() > 3) {
                    thisAmount += (this.getDayRented() - 3) * 1.5;
                }
                break;
        }

    接下来我们尝试消除这段长代码！！！

    根据策略模式的思想，我们可以让三个不同的类去继承Rental类，在Rental类中添加一个抽象方法，让各个子类去给出不同的实现，这样就可以取代不同的case。

abstract public class Rental {
    private Movie movie;
    private int dayRented;

    public Rental(Movie movie, int dayRented) {
        this.movie = movie;
        this.dayRented = dayRented;
    }

    public Movie getMovie() {
        return movie;
    }

    public int getDayRented() {
        return dayRented;
    }

    public double getAmount(){
        double thisAmount = 0d;
        return countThisAmount(thisAmount);
    }

    abstract public double countThisAmount(double thisAmount);
}

    之前的判断逻辑，全都被放到子类的继承的抽象方法去实现:

public class NewReleaseRental extends Rental {
    public NewReleaseRental(Movie movie, int dayRented) {
        super(movie, dayRented);
    }

    @Override
    public double countThisAmount(double thisAmount) {
        thisAmount += this.getDayRented() * 3;
        return thisAmount;
    }
}

public class RegularRental extends Rental {
        public RegularRental(Movie movie, int dayRented) {
            super(movie, dayRented);
        }

        @Override
        public double countThisAmount(double thisAmount) {
            thisAmount += 2;
            if (this.getDayRented() > 2) {
                thisAmount += (this.getDayRented() - 2) * 1.5;
            }
            return thisAmount;
        }
}

public class ChildrenRental extends Rental{
    public ChildrenRental(Movie movie, int dayRented) {
        super(movie, dayRented);
    }

    @Override
    public double countThisAmount(double thisAmount) {
        thisAmount += 1.5;
        if (this.getDayRented() > 3) {
            thisAmount += (this.getDayRented() - 3) * 1.5;
        }
        return thisAmount;
    }
}

    而原来的长方法，变得非常简洁，大大增强了可读性。

public double getAmount(){
        double thisAmount = 0d;
        return countThisAmount(thisAmount);
 }

适用场景

    策略模式正如其名字一样，提供不同的策略，用户只需要决定用哪个算法，算法内部被系统封装。因此，策略模式多用在算法决策系统中，对不同的输入做不同处理：

  • 以不同的格式保存文件;

  • 以不同的算法压缩文件;

  • 以不同的算法截获图象;

总结

    策略模式在重构代码中帮助很大，往往能消除长方法，大大提高代码的可读性。同时，经过策略模式重构后的代码更易于扩展，一旦有新的条件出现，直接构建一个新的策略就可以，不会影响其他代码。

关于重构代码的思考

    策略模式、模板模式、提取方法等都可以去重构代码，好处在于，更易于后期的维护和继续开发，利于代码重用，代码更具有可读性。但是重构也会带来一些问题，频繁的函数调用会更耗费内存，过度地重构浪费开发时间，说不定还会减少可读性。何解呢？业务需求必定是其一（emmmmmm），还是见仁见智吧，每个人都有自己的理解和行为习惯，只要你觉得ok，你的partners也ok，就ok(o)/~

知意不知一
关注
专栏目录
《重构-改善代码既有的设计》重构，第一个案例
limuzi13的专栏
11-16 3078
起点：编写3个类的代码 1、第一个类-影片(Movie)：package com.lee.test.aFirstExample;public class Movie { /** * @param title * @param priceCode */ public Movie(String title, int priceCode) {
JavaWeb——（12）事务与连接池
小唐要努力的博客
07-02 420
一、事务 1.1事务的概述 事务是指访问并可能更新数据库中数据项的执行单元，可以是一条sql语句、一组sql语句或者整个程序， 组成这组操作的各个单元，要么全部成功，要么全部失败。事务是恢复和并发控制的基本单位。 例如假设用户a要向用户b转账100块钱，后台数据库更新会对应两条sql语句： update account set money=money-100 where name='a'; update account set money=money+100 where name='...
小唐说设计模式————责任链模式
知意的博客
05-21 546
责任链模式（Chain of Responsibility ）的定义如下： Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request.Chain the receiving object and pass the request along the chain until an object handles it. 谷歌翻译：为多
小唐说设计模式————原型模式
知意的博客
05-21 203
什么是原型模式 原型模式（Prototype Pattern）是五种创建型模式的其中一种，用原型实例指定创建对象的种类作为原型，并且通过拷贝原型来创建新的对象。 为什么要使用原型模式 新建一个对象有时候会很麻烦，可能涉及大量的变量初始化，函数、代码块的执行，不仅浪费资源，还会涉及数据准备、访问权限等操作。 实现 原型模式至少涉及两个角色： Prototype，即原型类：需要实现Cloneable接口，并重写clone()方法，为外部提供一个克隆自身的方法; Client，即应用类：让一个原型克隆自身从而创
【Java设计模式】简单学中介者模式——唐长老，取经之路已帮你打点好了
winrh的博客
07-29 229
目录 说明 实现方式 应用场景 其他链接 说明 行为型模式之一，其他还有命令模式、模板方法模式、访问者模式、观察者模式、迭代器模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式) 中介者模式（Mediator Pattern，又叫调停者模式）：将对象间网状的联系转化为以中介为中心的星形结构。 优缺点都是集中控制 中介者承担了较多的责任，一旦中介者出现了问题，整个系统就会受到影响 实现方式 唐僧师徒四人西天取经，
JavaSE基础——（27）反射&JDK新特性
小唐要努力的博客
02-24 240
一、反射 1.1类的加载概述和加载时机 当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三步来实现对这个类进行初始化， 加载：就是将class文件（字节码文件）读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象 连接：连接分为验证，准备和解析三步 验证：是否有正确的内部结构，并和其他类协调一致 准备：负责为类的静态成员分配内存，并设置默认初始化值 解析：将类的二进制数据中的符号引用替换为直接引用 初始化：包...
SSM框架之RabbitMQ——消息中间件
小唐要努力的博客
02-13 2783
一、MQ的基本概念 1.1MQ概述 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。 多用于分布式系统之间进行通信。 在分布式系统中，通信主要包含两种方式：直接调用和借助第三方进行间接通信。 MQ消息队列就是这个第三方，我们也成为消息中间件，而发送数据的或者提供服务的A系统我们称为生产者，接收数据的B系统我们称为消费者。 1.2MQ的优缺点 MQ的优点主要包括： 应用解耦：提高系统容错性和可维护性 异步提速：提升用户体验和系统吞吐量..
java学习——IO流
m0_73245690的博客
04-26 990
FileInputStream:文件输入流BufferedInputStream:缓冲字节输入流ObjectInputStream:对象字节输入流（类的继承关系）通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定通过使用文件描述符fdObj创建一个FileInputStream，该文件描述符表示到文件系统中的某个实际文件的现有连接。
java学习——线程基本使用
m0_73245690的博客
04-09 1089
他们都实现了同一个接口，我们在实现被代理类的时候，我们不直接调用，而是转到代理类里面，去实现，当然我们最后调用的还是被代理类的方法，但是我们可以用代理类对方法进行处理。我们用T1，T2两个类去分别实现两个线程的创建，子线程的创建我们用的是实现Runnable接口来创建，然后我们在main主线程里面启动两个子线程。上面的代码我们有三个步骤，第一重写了run方法，第二在run方法里面我们使用了Thread.sleep方法做延迟，第三在我们调用这个线程的时候，我们底层使用的是start0()方法。
小唐链表交集.cpp
04-11
小唐链表交集.cpp
JavaWeb——JavaScript
qq_45821255的博客
06-25 5112
本文介绍了前端相关的基础知识，适合主要学习后端而想快速把前端知识过一遍。
JAVA基础——集合
qq_45821255的博客
03-12 492
文章目录前言一、集合概要及框架体系1、集合的理解2、数组的缺点3、集合的好处4、集合的框架体系二、Collection集合（单列集合）Collection集合特点Collection集合遍历元素方式1、迭代器的遍历方式2、增强for循环的遍历方式1、ListⅠ. ArrayList底层结构和源码分析Ⅱ Vector 底层结构和源码分析Vector子类——Stack(栈)Ⅲ LinkedList底层结构和源码分析Ⅳ. ArrayList 和 LinkedList 比较2.Set2.读入数据三、Map集合（双
设计模式的分类
SunnyRivers
09-25 844
设计模式，即Design Patterns，是指在软件设计中，被反复使用的一种代码设计经验。使用设计模式的目的是为了可重用代码，提高代码的可扩展性和可维护性。设计模式这个术语是上个世纪90年代由Erich Gamma、Richard Helm、Raplh Johnson和Jonhn Vlissides四个人总结提炼出来的，并且写了一本Design Patterns的书。这四人也被称为四人帮（GoF）。为什么要使用设计模式？
重修设计模式-设计原则
白泽的博客
09-19 1183
设计原则是软件编码时所遵循的规则，旨在帮助开发者创建出既满足功能需求又易于维护、可扩展且美观的设计，理解设计原则可以提升代码质量、减少错误以及促进团队协作，但对设计原则的理解要灵活，不要拿原则当真理，生搬硬套会适得其反。
超详细超实用！！！AI编程之cursor编写设计模式接口隔离原则实例（七）
qq_43206280的博客
09-25 479
客户端不应该被迫依赖于它不使用的方法，一个类对另一个类的依赖应该建立在最小的接口上。要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。
软件设计模式——工厂模式
最新发布
weixin_54859557的博客
09-25 703
软件设计模式——工厂模式
TypeScript 设计模式之【单例模式】
bobostudio1995的博客
09-20 518
单例模式是一种创建型设计模式，它在确保一个类只有一个实例，隐藏了内部实现，并提供一个全局访问点，从而节省资源，提高性能。喜欢的话就❤️，关注一下吧，有问题也欢迎讨论指教。！！下期预告：TypeScript 设计模式之【原型模式】
十一、SOA（SOA的具体设计模式）
xiaoqi270620903的专栏
09-19 921
SOA架构设计模式提供了多种解决方案，帮助架构师在设计、集成和管理分布式服务时处理各种复杂场景。这些设计模式涵盖了从服务的设计与组合到消息处理、服务治理和企业服务总线的实现。通过合理使用这些模式，企业可以构建出高效、灵活、可扩展的系统架构，支持复杂业务需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值