《重构》增强代码可读性

最新推荐文章于 2024-07-25 13:23:14 发布
最新推荐文章于 2024-07-25 13:23:14 发布
阅读量345 收藏 1
点赞数
分类专栏： Java进阶学习 文章标签： 重构 java 面试 代码规范
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42709715/article/details/129554085
版权

文章目录


在这里插入图片描述

重构原则

何为重构

不改变代码本身可观察的行为，进行代码的构造变化

为何重构

  1. 消除重复代码，方便未来的修改
  2. 利用重构协助理解不熟悉的代码
  3. 提高以后维护代码的速率

何时重构

  1. 添加代码时
  2. 修改bug时
  3. 复审代码质量时

重构会影响性能吗

可能会，但原则是先写出能完善的代码，再测试性能

实例

原始类

在这里插入图片描述

Movie类：该类主要记录类型、价格和标题等，是单纯数据类。

/**
 * Movie记录类型、价格和标题等，单纯数据类。
 */
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;
    }
}

Rental类：表示某位顾客租了一部影片，表示行为。

/**
 * Rental表示某位顾客租了一部影片,表示行为。
 */
class Rental {
    private Movie movie;
    private int daysRented;
 
    public Rental(Movie movie, int daysRented) {
        this.movie = movie;
        this.daysRented = daysRented;
    }
 
    public int getDaysRented() {
        return daysRented;
    }
 
    public Movie getMovie() {
        return movie;
    }
}

Customer类：表示顾客，有数据和相应的访问函数。

/**
 * Customer表示顾客，有数据和相应的访问函数
 */
public class Customer {
    private String name;
    private Vector rentals = new Vector();
 
    public Customer(String name) {
        this.name = name;
    }
 
    public void addRental(Rental rental) {
        rentals.add(rental);
    }
 
    public String getName() {
        return name;
    }
 
    /**
     * 提供一个用于生成详单的函数
     */
    public String statement() {
        double totalAmount = 0;
        //常客计算积分时使用
        int frequentRenterPoints = 0;
        Enumeration enumeration = rentals.elements();
        String result = "Rental Record for " + getName() + "\n";
        while (enumeration.hasMoreElements()) {
            //总金额
            double thisAmount = 0;
            Rental each = (Rental) rentals.elements();
            switch (each.getMovie().getPriceCode()) {
                case Movie.REGULAR:
                    thisAmount += 2;
                    //优惠力度
                    if (each.getDaysRented() > 2) {
                        thisAmount += (each.getDaysRented() - 2) * 1.5;
                    }
                    break;
                case Movie.NEW_RELEASE:
                    //果然还是新书最贵啊
                    thisAmount += each.getDaysRented() * 3;
                    break;
                case Movie.CHILDRENS:
                    thisAmount += 1.5;
                    if (each.getDaysRented() > 3) {
                        thisAmount += (each.getDaysRented() - 3) * 1.5;
                    }
                    break;
            }
            frequentRenterPoints++;
            //如果是新书，另算积分呢
            if (each.getMovie().getPriceCode() == Movie.NEW_RELEASE && each.getDaysRented() >= 1) {
                frequentRenterPoints++;
            }
            result += "\t" + each.getMovie().getTitle() + "\t" + String.valueOf(thisAmount) + "\n";
            totalAmount += thisAmount;
        }
        result += "Amount owed is " + String.valueOf(totalAmount) + "\n";
        result += "You earned " + String.valueOf(frequentRenterPoints) + " frequent renter points";
        return result;
    }
}

进行重构

分解statements方法

长长的函数需要大卸八块，代码块越小，代码的移动和处理也就越轻松。将较小代码块移至更合适的类，降低代码重复使新函数更容易撰写。

提取函数

找出逻辑泥团并运用提取函数方法。本例中的switch语句需提炼至独立函数。找出函数内局部变量和参数。each（未被修改，可以当成参数传入新的函数）和thisAmount（会被修改，格外小心，如果只有一个变量修改，可以将其作为返回值）。那么将新函数返回值返回给thisAmount是可行的。

/**
 * 提供一个用于生成详单的函数
 */
public String statement() {
    .​...
    while (enumeration.hasMoreElements()) {
        //总金额
        double thisAmount = 0;
        Rental each = (Rental) rentals.elements();
        thisAmount = amountFor(each);
        ....
    }
    .​...
}
 
/**
 * 金额计算
 * @param aRental
 * @return
 */
private double amountFor(Rental aRental) {
    //注意double、int类型之间的转换。
    double result = 0;
    switch (aRental.getMovie().getPriceCode()) {
        case Movie.REGULAR:
            result += 2;
            //优惠力度
            if (aRental.getDaysRented() > 2) {
                result += (aRental.getDaysRented() - 2) * 1.5;
            }
            break;
        case Movie.NEW_RELEASE:
            //果然还是新书最贵啊
            result += aRental.getDaysRented() * 3;
            break;
        case Movie.CHILDRENS:
            result += 1.5;
            if (aRental.getDaysRented() > 3) {
                result += (aRental.getDaysRented() - 3) * 1.5;
            }
            break;
    }
    return result;
}
搬移函数

观察上一步提炼出来的amountFor函数，使用了Rental类的信息却没有使用来自Customer类的信息，函数是应该放在它所使用的数据的对象内的，所以amountFor应该要放到Rental类而非Customer类，调整代码以使用新类。

class Rental {
    ....
    /**
     * 金额计算
     * @return
     */
    public double getCharge() {
        //注意double、int类型之间的转换。
        double result = 0;
        switch (getMovie().getPriceCode()) {
            case Movie.REGULAR:
                result += 2;
                //优惠力度
                if (getDaysRented() > 2) {
                    result += (getDaysRented() - 2) * 1.5;
                }
                break;
            case Movie.NEW_RELEASE:
                //果然还是新书最贵啊
                result += getDaysRented() * 3;
                break;
            case Movie.CHILDRENS:
                result += 1.5;
                if (getDaysRented() > 3) {
                    result += (getDaysRented() - 3) * 1.5;
                }
                break;
        }
        return result;
    }
}

public class Customer {
    ....
    /**
     * 提供一个用于生成详单的函数
     */
    public String statement() {
        ....
        while (enumeration.hasMoreElements()) {
            ...
            result += "\t" + each.getMovie().getTitle() + "\t" 
                 + String.valueOf(each.getCharge()) + "\n";
            totalAmount += each.getCharge();
        }
        .​..
    }
}
提炼“积分计算”功能

积分计算因影片种类而有所不同，针对“积分计算”代码运用Extract Method重构手法。局部变量each，另一个临时变量是frequentRenterPoints(这个参数在使用之前已初始化，但提炼出的函数并未读取该值，因此无需传入，只需作为新函数的返回值累加上去即可)。

class Rental {
     ...
    /**
     * 计算常客积分
     * @return
     */
    public int getFrequentRenterPoints() {
        //如果是新书，另算积分呢
        if (getMovie().getPriceCode() == Movie.NEW_RELEASE && getDaysRented() >= 1) {
            return 2;
        } else {
            return 1;
        }
    }
}

public class Customer {
    ....
    /**
     * 提供一个用于生成详单的函数
     */
    public String statement() {
        double totalAmount = 0;
        //常客计算积分时使用
        int frequentRenterPoints = 0;
        Enumeration enumeration = rentals.elements();
        String result = "Rental Record for " + getName() + "\n";
        while (enumeration.hasMoreElements()) {
            Rental each = (Rental) rentals.elements();
            //计算常客积分
            frequentRenterPoints += each.getFrequentRenterPoints();
            result += "\t" + each.getMovie().getTitle() + "\t" + String.valueOf(each.getCharge()) + "\n";
            totalAmount += each.getCharge();
        }
        result += "Amount owed is " + String.valueOf(totalAmount) + "\n";
        result += "You earned " + String.valueOf(frequentRenterPoints) + " frequent renter points";
        return result;
    }
}
去除临时变量（以查询取代临时变量）

临时变量会造成冗长复杂的函数，以查询取代临时变量方法，以查询函数替代totalAmount和frequentRentalPoints临时变量。任何函数均可调用，促成干净设计、减少冗长函数。

public class Customer {
    ...
    /**
     * 提供一个用于生成详单的函数
     */
    public String statement() {
        //常客计算积分时使用
        Enumeration enumeration = rentals.elements();
        String result = "Rental Record for " + getName() + "\n";
        while (enumeration.hasMoreElements()) {
            Rental each = (Rental) rentals.elements();
            result += "\t" + each.getMovie().getTitle() + "\t" + String.valueOf(each.getCharge()) + "\n";
        }
        result += "Amount owed is " + String.valueOf(getTotalCharge()) + "\n";
        result += "You earned " + String.valueOf(getTotalFrequentRenterPoints()) + " frequent renter points";
        return result;
    }
 
    /**
     * 获取总积分
     * @return
     */
    private double getTotalFrequentRenterPoints() {
        int result = 0;
        Enumeration enumeration = rentals.elements();
        while (enumeration.hasMoreElements()) {
            Rental each = (Rental) rentals.elements();
            result += each.getFrequentRenterPoints();
        }
        return result;
    }
 
    /**
     * 获取总金额
     * @return
     */
    private double getTotalCharge() {
        double result = 0;
        Enumeration enumeration = rentals.elements();
        while (enumeration.hasMoreElements()) {
            Rental each = (Rental) rentals.elements();
            result +=  each.getCharge();
        }
        return result;
    }
}
运用多态取代与价格相关的条件逻辑
代码迁移Movie类

用户准备修改影片分类规则。费用计算和常客积分计算也会因此而发生改变。因为系统可能会加入新影片类型，不稳定，因此在Movie对象内计算费用。同样的手法处理常客积分函数。

public class Movie {
   ...
    /**
     * 根据影片类型获取费用
     * @param daysRented
     * @return
     */
    public double getCharge(int daysRented) {
        double result = 0;
        switch (getPriceCode()) {
            case Movie.REGULAR:
                result += 2;
                //优惠力度
                if (daysRented > 2) {
                    result += (daysRented - 2) * 1.5;
                }
                break;
            case Movie.NEW_RELEASE:
                //果然还是新书最贵啊
                result += daysRented * 3;
                break;
            case Movie.CHILDRENS:
                result += 1.5;
                if (daysRented > 3) {
                    result += (daysRented - 3) * 1.5;
                }
                break;
        }
        return result;
    }
 
    public int getFrequentRenterPoints(int daysRented) {
        //如果是新书，另算积分呢
        if (getPriceCode() == Movie.NEW_RELEASE && daysRented >= 1) {
            return 2;
        } else {
            return 1;
        }
    }
}

class Rental {
    private Movie movie;
    private int daysRented;
    .​..
    /**
     * 金额计算
     * @return
     */
    public double getCharge() {
        return movie.getCharge(daysRented);
    }
 
    /**
     * 计算常客积分
     * @return
     */
    public int getFrequentRenterPoints() {
        return movie.getFrequentRenterPoints(daysRented);
    }
}
Price类 状态模式

多态取代switch语句，多态设计时不要直接继承Movie，而是通过Price间接去处理，一部影片可以在生命周期内修改自己的分类，但一个对象却不能再生命周期内修改自己所属的类，使用state模式

abstract class Price {
    abstract  int getPriceCode();
}
public class ChildrenPrice extends Price{
    @Override
    int getPriceCode() {
        return Movie.CHILDRENS;
    }
}
public class NewReleasePrice extends Price {
    @Override
    int getPriceCode() {
        return Movie.NEW_RELEASE;
    }
}
public class RegularPrice extends Price {
    @Override
    int getPriceCode() {
        return Movie.REGULAR;
    }
}

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 Price price;
 
    public Movie(String title, int priceCode) {
        this.title = title;
        setPriceCode(priceCode);
    }
 
    public int getPriceCode() {
        return price.getPriceCode();
    }
 
    public void setPriceCode(int arg) {
        switch (arg) {
            case Movie.REGULAR:
                price = new RegularPrice();
                break;
            case Movie.NEW_RELEASE:
                price = new NewReleasePrice();
                break;
            case Movie.CHILDRENS:
                price = new ChildrenPrice();
                break;
            default:
                throw new IllegalArgumentException("Incorrect Price Code");
        }
    }
    ....
    }
 }
搬移函数

将Movie中的getCharge方法下沉至Price方法中。

abstract class Price {
    abstract int getPriceCode();
    /**
     * 根据影片类型获取费用
     * @param daysRented
     * @return
     */
    public double getCharge(int daysRented) {
        double result = 0;
        switch (getPriceCode()) {
            case Movie.REGULAR:
                result += 2;
                //优惠力度
                if (daysRented > 2) {
                    result += (daysRented - 2) * 1.5;
                }
                break;
            case Movie.NEW_RELEASE:
                //果然还是新书最贵啊
                result += daysRented * 3;
                break;
            case Movie.CHILDRENS:
                result += 1.5;
                if (daysRented > 3) {
                    result += (daysRented - 3) * 1.5;
                }
                break;
        }
        return result;
    }
}

public class Movie {
    private Price price;
    .​..
 
    public int getPriceCode() {
        return price.getPriceCode();
    }
    ....
}
以多态取代表达式

次取出getPriceCode的一个case分支，在对应的类建立覆盖函数。同样的方法处理getFrequentRenterPoints方法

/**
 * 新建Price类，并提供类型相关的行为，为此，加入抽象函数，并在所有子类中加上对应的具体操作。
 */
abstract class Price {
    /**
     * 获取影片类型code码
     * @return
     */
    abstract  int getPriceCode();
    /**
     * 根据影片类型获取费用
     * @param daysRented
     * @return
     */
    abstract double getCharge(int daysRented);
 
    /**
     * 如果是新书，采用复写的方法，在超类中留下一个已定义的函数，使之成为一种默认行为。
     * @param daysRented
     * @return
     */
    int getFrequentRenterPoints(int daysRented) {
        return 1;
    }
}

public class RegularPrice extends Price {
    @Override
    int getPriceCode() {
        return Movie.REGULAR;
    }
 
    @Override
    public double getCharge(int daysRented) {
        double result = 2;
        //优惠力度
        if (daysRented > 2) {
            result += (daysRented - 2) * 1.5;
        }
        return result;
    }
}

public class NewReleasePrice extends Price {
    @Override
    int getPriceCode() {
        return Movie.NEW_RELEASE;
    }
 
    @Override
    public double getCharge(int daysRented) {
        //果然还是新书最贵啊
        return daysRented * 3;
    }
 
    @Override
    public int getFrequentRenterPoints(int daysRented) {
        return (daysRented > 1) ? 2 : 1;
    }
}

public class ChildrenPrice extends Price{
    @Override
    int getPriceCode() {
        return Movie.CHILDRENS;
    }
 
    @Override
    public double getCharge(int daysRented) {
        double result = 1.5;
        if (daysRented > 3) {
            result += (daysRented - 3) * 1.5;
        }
        return result;
    }
}

重构之后的类图
在这里插入图片描述

我觉得海星_98
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《重构-改善代码既有的设计》重构，第一个案例
limuzi13的专栏
11-16 3063
起点：编写3个类的代码 1、第一个类-影片(Movie)：package com.lee.test.aFirstExample;public class Movie { /** * @param title * @param priceCode */ public Movie(String title, int priceCode) {
《重构--改善既有代码的设计》读书笔记之三：分解并重组statement() part2
PBA_WORLD
04-08 800
运用Replace Temp with Query把statement()中的totalAmount 和 frequentRenterPoints临时变量去掉： 用Customer类的getTotalCharge()取代totalAmount 用Customer类的getTotalFrequentRenterPoints()取代frequentRenterPoints 最后，我们
《重构》 — Java示例：影片出租店程序（3、重构——分解并重组Statement）
starsky2006的专栏
04-15 2104
示例：影片出租店程序（重构——分解并重组Statement） 步骤： 1、提炼“金额计算”代码 1.1、提炼“逻辑泥团”——“提炼方法（Extract Method）” Statement()中一个明显的“逻辑泥团”就是switch语句，把它提炼到独立函数“AmountFor”中。 Eclipse工具重构步骤： （1）、选中代码   （2）、右键选择“Extract Method”   （3）、输入
《重构 改善既有代码的设计》之重构，第一个案例详解
不当初
01-30 2798
1 简介 《重构 改善既有代码的设计》这本书是Martin Fowler等人撰写的一本关于代码重构的十分精彩的书籍，使用Java语言进行阐明主题，是一本非常精彩，甚至要成为优秀程序员不容错过的专业书籍。自己是2019-01-01在浙江图书馆开始看这本书，到2019-01-20在MBA405教读完这本书，感觉收获匪浅，为了防止遗忘，现在开始对这本书进行抽丝拨茧，把在阅读过程中遇到的一些问题进行摘抄出...
python函数增强代码可读性_如何提高代码的可读性 学习笔记
weixin_29442195的博客
03-02 452
本文整理自 taowen 师傅在滴滴内部的分享。1.Why对一线开发人员来说，每天工作内容大多是在已有项目的基础上继续堆代码。当项目实在堆不动时就需要寻找收益来重构代码。既然我们的大多数时间都花在坐在显示器前读写代码这件事上，那可读性不好的代码都是在谋杀自己or同事的生命，所以不如一开始就提炼技巧，努力写好代码; )2.How为提高代码可读性，先来分析代码实际运行环境。代码实际运行于两个地方：cp...
保持代码健康，经常进行重构
创意程序员的博客
04-16 359
通过定期进行代码审查、制定重构计划、使用合适的工具和技术、遵循编程原则和设计模式，以及学习借鉴他人的经验，程序员可以不断改进自己的代码，提高软件开发的质量和效率，为项目的成功做出贡献。在项目的初期，为了满足快速开发和交付的需求，代码可能会出现一些性能上的问题，例如低效的算法、不合理的数据结构等。通过重构，可以对这些性能问题进行优化，提高代码的运行效率，减少资源消耗，从而提升系统的性能和响应速度。重构的过程中，程序员可以通过优化代码结构、简化复杂的逻辑、去除冗余代码、修复潜在的bug等方式，改善代码的质量。
关于代码重构的思考
csdnklsdm的博客
12-13 353
什么是重构？ 软件设计大师Martin Fowler是这样定义重构的：“重构是一种对软件内部结构的改善，目的是在不改变软件的可见行为的情况下，使其更易理解，维护成本更低。”因此，本质上来讲，重构就是不改变功能的前提下，改进软件的设计。 为什么要重构？ 1.降低维护成本 项目在演进，代码在堆砌，这个过程中伴随着需求的变化、技术的更新、人员的流动，如果没有人关注代码的质量，代码一定会越来越混乱。当混乱到一定程度，量变引起质变，项目的维护成本很可能已经高过重新开发的成本。 2.设计缺陷 优秀的代码并不是一开始就完
重构，改善既有代码的设计（理论篇）
云瀚的自习室
07-16 3511
本文是笔者毕业后的第一篇blog，将从三个方面讨论代码重构。即：1.代码重构是什么；2.常用的重构手法；3.代码中的“坏味道”。本篇blog是《重构，改善代码既有代码的设计》一文的读书笔记，读书笔记与书一起食用效果更佳哦。
Java中的代码重构：技巧、优秀实践与方法
pantouyuchiyu的博客
10-19 856
Java 代码重构是一种在不影响代码外部行为的前提下进行的代码优化，它通过渐进和小规模的优化来改善现有代码的结构和质量。重构的目标是提高代码的可读性、性能、可维护性和效率等。
浅谈CSS代码重构
09-24
【CSS代码重构】是优化和改进现有CSS代码的过程，旨在提高代码的可读性、可维护性和性能，同时保持原有功能不变。重构的关键在于改善代码结构，使其更符合最佳实践和设计模式，以便团队协作和长期项目的可持续发展。...
架构与代码质量重构实践
08-03
"架构与代码质量重构实践"的主题旨在探讨如何通过有效的重构技术来提升系统架构的稳定性和代码的可维护性，从而实现软件项目的长期健康发展。 架构重构是针对现有系统的整体结构进行改进的过程，目的是提高系统的...
产品中的代码重构.pdf
08-28
重构是对软件内部结构的调整，不改变其外部行为，目的是增强代码的可理解性，降低修改成本。重构与性能优化虽然都能改变代码结构，但重构更注重于提升代码质量，而性能优化则侧重于提高运行效率，可能会牺牲一定的...
31天代码重构快速优化代码
12-04
16. **拆分临时变量**：将大型临时变量拆分为多个小变量，提高代码可读性。 17. **使用本地化变量**：避免过长的作用域，减少副作用风险。 18. **将条件表达式改为多态**：利用多态性替换条件判断，使代码更简洁。 ...
既有代码重构
09-07
1. **提高代码可读性**：通过整理和简化代码结构，使得团队成员更容易理解代码的意图和工作方式，从而降低维护成本。 2. **增强代码可维护性**：通过消除坏味道（如过长方法、重复代码、紧密耦合等）和引入设计模式...
【题解 && Kruskal重构树 && LCA】 星际导航
鹭天
07-21 1041
如果x和y不连通，说明我们这个时候甚至找不到x和y的一条路径，也就无法求最大边的最小值。因为如果我们不要这条边，而选择后面的边，让x和y能够连通，后面的边显然都比他大。首先我们明白，两个点之间的路径，其实是一个生成子图，或者说生成子树。想要最大边最小，其实感性理解一下，就等价于让两个点连通的代价最小。因为这是让x和y连通加入的最后一条边，前面的加边都比他小。于是两个点之间的最大边权就变成了重构树上的LCA的点权。我们回想最小生成树的思路，这个时候有两个点x和y。也就是x到y路径上的最大边的最小值。
基于面向对象重构模型训练器
golfxiao的专栏
07-24 591
深度学习领域我们常用jupyter来演练代码，但实际生产环境中不可能像jupyter一样，所有代码逻辑都在面向过程编程，这会导致代码可复用性差，维护难度高。本文我们将要对整个训练循环的逻辑进行重构，采用封装的方式来提升代码的可复用性，降低维护难度。
【公式解释】《系统论》《控制论》《信息论》的共同重构：探索核心公式与深度解析
最新发布
认知计算_茂森的博客
07-25 587
系统论》《控制论》《信息论》的共同重构：探索核心公式与深度解析。
力扣767.重构字符串
Pisasama的博客
07-25 79
将每个字母的出现次数存在哈希表中。
网站重构怎么进行
weixin_65644264的博客
07-23 415
网站重构是一项复杂的任务，涉及许多方面，从技术实现到用户体验的提升。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值