Java构造函数中多重if语句的优化与重构实践-java教程-PHP中文网

Java构造函数中多重if语句的优化与重构实践

本文旨在探讨并提供多种策略，以优化Java构造函数中冗余且复杂的if语句链。通过引入条件运算符、提取公共辅助方法以及重构为数组结构等手段，可以有效提升代码的可读性、可维护性和扩展性，最终实现更简洁、专业的代码设计。

原始问题分析

在java编程中，尤其是在构造函数或方法内部，我们常常会遇到需要根据不同条件进行参数校验或值初始化的场景。当这些条件判断逻辑变得复杂且重复时，往往会导致一长串的if-else语句，使代码变得冗长、难以阅读和维护。例如，以下是一个典型的案例，在一个latency类的构造函数中，存在多重if语句用于参数校验和条件赋值：

public class Latency {
    private double full;
    private double cpuOne;
    private double cpuTwo;
    private double cpuThree;
    private double cpuFour;

    public Latency(final double full, final double cpuOne, final double cpuTwo, final double cpuThree, final double cpuFour) {
        if (full > 10.0 || (full <= 0.0)) {
            throw new IllegalArgumentException("Must check the values");
        }
        this.full = full;
        if (cpuOne == 0 && cpuTwo == 0 && cpuThree == 0 && cpuFour == 0) {
            throw new IllegalArgumentException("not all can be zero");
        } else {
            if (cpuOne == 0.5) {
                this.cpuOne = full;
            } else {
                this.cpuOne = cpuOne;
            }
            if (cpuTwo == 0.5) {
                this.cpuTwo = full;
            } else {
                this.cpuTwo = cpuTwo;
            }
            if (cpuThree == 0.5) {
                this.cpuThree = full;
            } else {
                this.cpuThree = cpuThree;
            }
            if (cpuFour == 0.5) {
                this.cpuFour = full;
            } else {
                this.cpuFour = cpuFour;
            }
        }
    }
}

登录后复制

这段代码的问题在于：

冗余性： 针对cpuOne到cpuFour的if (value == 0.5)判断和赋值逻辑重复了四次。
可读性差： 嵌套的if-else结构增加了代码的认知负担。
不易维护： 如果需要修改0.5这个特殊值的处理逻辑，需要修改四处代码。
扩展性差： 如果未来需要增加cpuFive、cpuSix，则需要复制粘贴更多的if-else块。

针对这些问题，我们可以采用多种重构策略来优化代码。

重构策略

策略一：利用条件运算符（三元表达式）

条件运算符（? :）提供了一种简洁的方式来表达简单的if-else赋值逻辑。它能将一行if-else语句压缩为一行表达式，显著减少代码行数，提高简洁性。

实现示例：

立即学习“Java免费学习笔记（深入）”；

public Latency(final double full, final double cpuOne, final double cpuTwo, final double cpuThree, final double cpuFour) {
    if (full > 10.0 || (full <= 0.0)) {
        throw new IllegalArgumentException("Must check the values");
    }
    this.full = full;

    if (cpuOne == 0 && cpuTwo == 0 && cpuThree == 0 && cpuFour == 0) {
        throw new IllegalArgumentException("not all can be zero");
    } else {
        this.cpuOne = cpuOne == 0.5 ? full : cpuOne;
        this.cpuTwo = cpuTwo == 0.5 ? full : cpuTwo;
        this.cpuThree = cpuThree == 0.5 ? full : cpuThree;
        this.cpuFour = cpuFour == 0.5 ? full : cpuFour;
    }
}

登录后复制

优点：

Phenaki

phenaki是一种从文本生成视频的模型

查看详情

代码更紧凑，减少了冗余的if-else关键字。
对于简单的条件赋值场景，可读性更佳。

注意事项：

不适用于复杂的逻辑，过度使用可能导致难以理解的表达式。
条件运算符只能用于表达式，不能替代包含多条语句的if-else块。

策略二：提取公共辅助方法

当多处代码块执行相同的逻辑时，可以将其封装到一个独立的辅助方法中。这遵循了“Don't Repeat Yourself (DRY)”原则，提高了代码的复用性，减少了错误发生的可能性。

实现示例：

立即学习“Java免费学习笔记（深入）”；

首先，定义一个私有的静态辅助方法：

public class Latency {
    // ... 现有成员变量 ...

    private static double changeHalfToFull(double value, double full) {
        if (value == 0.5) {
            return full;
        } else {
            return value;
        }
    }

    // 构造函数中使用该方法
    public Latency(final double full, final double cpuOne, final double cpuTwo, final double cpuThree, final double cpuFour) {
        if (full > 10.0 || (full <= 0.0)) {
            throw new IllegalArgumentException("Must check the values");
        }
        this.full = full;

        if (cpuOne == 0 && cpuTwo == 0 && cpuThree == 0 && cpuFour == 0) {
            throw new IllegalArgumentException("not all can be zero");
        } else {
            this.cpuOne = changeHalfToFull(cpuOne, full);
            this.cpuTwo = changeHalfToFull(cpuTwo, full);
            this.cpuThree = changeHalfToFull(cpuThree, full);
            this.cpuFour = changeHalfToFull(cpuFour, full);
        }
    }
}

登录后复制

优点：

DRY原则： 核心逻辑只实现一次，减少了重复代码。
可维护性： 逻辑修改只需在一个地方进行。
可读性： 通过方法名清晰表达了操作的意图。
静态方法： 如果方法不依赖于实例状态，定义为static可以避免不必要的对象创建，并提高性能。

策略三：引入数组优化数据结构

如果多个参数（如cpuOne到cpuFour）在概念上是同类项，且处理逻辑相似，那么将它们组织成一个数组是更优雅的解决方案。这不仅能简化代码，还能明确表达这些数据之间的关联性，提高代码的扩展性。

实现示例：

立即学习“Java免费学习笔记（深入）”；

首先，修改类的成员变量，用一个数组来存储CPU值：

public class Latency {
    private double full;
    private double[] cpuValues; // 使用数组存储CPU值

    // 构造函数参数也改为数组
    public Latency(final double full, final double[] cpuValues) {
        if (full > 10.0 || (full <= 0.0)) {
            throw new IllegalArgumentException("Must check the values");
        }
        if (cpuValues == null || cpuValues.length != 4) { // 校验数组长度
            throw new IllegalArgumentException("cpuValues must be an array of 4 elements");
        }

        // 校验所有cpu值不能同时为0
        boolean allCpuZero = true;
        for (double val : cpuValues) {
            if (val != 0) {
                allCpuZero = false;
                break;
            }
        }
        if (allCpuZero) {
            throw new IllegalArgumentException("not all cpu values can be zero");
        }

        this.full = full;
        this.cpuValues = new double[4]; // 初始化内部数组

        for (int index = 0; index < cpuValues.length; index++) {
            if (cpuValues[index] == 0.5) {
                 this.cpuValues[index] = full;
            } else {
                 this.cpuValues[index] = cpuValues[index];
            }
        }
    }
}

登录后复制

优点：

代码简洁： 通过循环处理数组元素，消除了大量重复代码。
易于扩展： 如果CPU数量增加，只需修改数组大小和循环边界，无需添加新的变量和if-else块。
语义清晰： 明确表达了cpuValues是一组相关的数值。
更易于参数传递： 当参数数量很多时，传递一个数组比传递多个独立参数更方便。

策略四：组合多种重构方法

最强大的重构往往是多种策略的组合。将条件运算符、辅助方法和数组结构结合起来，可以实现最简洁、最优雅的代码。

实现示例：

立即学习“Java免费学习笔记（深入）”；

public class Latency {
    private double full;
    private double[] cpuValues;

    // 辅助方法，使用条件运算符简化
    private static double changeHalfToFull(double value, double full) {
        return value == 0.5 ? full : value;
    }

    public Latency(final double full, final double[] cpuValues) {
        // 初始参数校验
        if (full > 10.0 || (full <= 0.0)) {
            throw new IllegalArgumentException("Full value must be between 0.0 (exclusive) and 10.0 (inclusive).");
        }
        if (cpuValues == null || cpuValues.length != 4) {
            throw new IllegalArgumentException("cpuValues must be an array of 4 elements.");
        }

        // 校验所有cpu值不能同时为0
        boolean allCpuZero = true;
        for (double val : cpuValues) {
            if (val != 0) {
                allCpuZero = false;
                break;
            }
        }
        if (allCpuZero) {
            throw new IllegalArgumentException("Not all cpu values can be zero.");
        }

        this.full = full;
        this.cpuValues = new double[4]; // 初始化内部数组

        // 结合数组和辅助方法进行赋值
        for (int index = 0; index < cpuValues.length; index++) {
            this.cpuValues[index] = changeHalfToFull(cpuValues[index], full);
        }
    }
}

登录后复制

优点：

集成了所有策略的优势，代码高度简洁、可读性强、易于维护和扩展。
通过辅助方法封装了核心逻辑，并通过数组结构化了数据，使得代码意图更加清晰。

注意事项与最佳实践

代码可读性优先： 虽然目标是简洁，但始终要优先考虑代码的可读性。过度压缩代码或使用过于复杂的单行表达式可能会适得其反。
DRY原则： 识别并消除重复代码是重构的关键。任何重复三次以上的代码都应该考虑提取为方法或封装。
异常处理： 构造函数中的参数校验至关重要。使用IllegalArgumentException等标准异常来指示无效的输入，确保对象状态的有效性。
数据结构选择： 当多个变量在语义上是同一组数据时，优先考虑使用数组、列表或自定义对象来封装它们，而不是使用多个独立的变量。这不仅能简化代码，还能提高代码的表达力。
代码意图： 重构的最终目的是让代码更好地表达其意图。选择最能清晰传达“为什么”和“做什么”的重构方式。
final关键字： 在方法参数中使用final关键字可以明确表示该参数在方法内部不会被修改，有助于提高代码的清晰度。
switch语句的局限性： switch语句不能直接用于double、float等浮点类型，只能用于int、char、byte、short、String（Java 7+）和枚举类型。因此，对于浮点数的条件判断，if-else或条件运算符是主要选择。