原始问题分析
在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;
}
}优点：
- 代码更紧凑，减少了冗余的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或条件运算符是主要选择。
总结
优化Java构造函数中多重if语句是提升代码质量的重要一环。通过灵活运用条件运算符、提取公共辅助方法以及重构为数组等策略，并结合实际项目需求进行组合，我们可以将冗余、复杂的代码转化为简洁、高效且易于维护的专业代码。选择合适的重构方法，不仅能提高开发效率，也能为项目的长期健康发展奠定基础。
