在Java编程中，条件表达式是控制程序流程的核心部分，但当业务逻辑复杂时，嵌套的多层if-else或者冗长的三元表达式会让代码变得难以阅读和维护。掌握简化条件表达式的方法，能够有效提升代码质量。
提取布尔变量替代复杂判断
当条件表达式中包含多个逻辑运算组合时，直接写在判断语句里会让可读性变差，此时可以把整个判断逻辑提取为有意义的布尔变量。
优化前的代码：
public class OrderService {
public boolean canProcessOrder(Order order) {
// 判断订单状态为已支付、订单金额大于0、用户不是黑名单、库存充足
if (order.getStatus() == 1 && order.getAmount() > 0 && !order.getUser().isBlack() && order.getStockCount() > order.getBuyCount()) {
return true;
}
return false;
}
}
优化后的代码：
public class OrderService {
public boolean canProcessOrder(Order order) {
// 提取布尔变量，明确每个判断的含义
boolean isPaid = order.getStatus() == 1;
boolean hasValidAmount = order.getAmount() > 0;
boolean isNotBlackUser = !order.getUser().isBlack();
boolean hasEnoughStock = order.getStockCount() > order.getBuyCount();
return isPaid && hasValidAmount && isNotBlackUser && hasEnoughStock;
}
}
使用卫语句提前返回
当条件判断中存在多个异常分支时，嵌套的if-else会让代码缩进层级过深，使用卫语句可以把异常逻辑提前处理并返回，减少嵌套。
优化前的代码：
public class UserService {
public String getUserInfo(Long userId) {
if (userId != null) {
User user = userDao.findById(userId);
if (user != null) {
if (user.getStatus() == 1) {
return user.getName();
} else {
return "用户已被禁用";
}
} else {
return "用户不存在";
}
} else {
return "用户ID不能为空";
}
}
}
优化后的代码：
public class UserService {
public String getUserInfo(Long userId) {
// 卫语句提前处理异常分支
if (userId == null) {
return "用户ID不能为空";
}
User user = userDao.findById(userId);
if (user == null) {
return "用户不存在";
}
if (user.getStatus() != 1) {
return "用户已被禁用";
}
return user.getName();
}
}
合并重复的条件分支
当多个条件分支执行相同的逻辑时，可以把这些条件合并，减少重复代码。
优化前的代码：
public class DiscountService {
public double getDiscount(int userLevel) {
if (userLevel == 1) {
return 0.9;
} else if (userLevel == 2) {
return 0.9;
} else if (userLevel == 3) {
return 0.8;
} else if (userLevel == 4) {
return 0.8;
} else {
return 1.0;
}
}
}
优化后的代码：
public class DiscountService {
public double getDiscount(int userLevel) {
// 合并相同结果的条件
if (userLevel == 1 || userLevel == 2) {
return 0.9;
} else if (userLevel == 3 || userLevel == 4) {
return 0.8;
} else {
return 1.0;
}
}
}
用枚举替代多分支条件判断
当条件判断是基于某个固定值的多分支场景时，比如根据类型执行不同逻辑，可以用枚举来封装对应的行为，替代冗长的if-else或者switch语句。
优化前的代码：
public class PaymentService {
public String processPayment(int payType) {
if (payType == 1) {
return "处理支付宝支付";
} else if (payType == 2) {
return "处理微信支付";
} else if (payType == 3) {
return "处理银行卡支付";
} else {
return "不支持的支付方式";
}
}
}
优化后的代码：
// 定义支付类型枚举
public enum PayTypeEnum {
ALIPAY(1, "支付宝支付") {
@Override
public String process() {
return "处理支付宝支付";
}
},
WECHAT(2, "微信支付") {
@Override
public String process() {
return "处理微信支付";
}
},
BANK_CARD(3, "银行卡支付") {
@Override
public String process() {
return "处理银行卡支付";
}
};
private final int code;
private final String desc;
PayTypeEnum(int code, String desc) {
this.code = code;
this.desc = desc;
}
public abstract String process();
// 根据code获取枚举实例
public static PayTypeEnum getByCode(int code) {
for (PayTypeEnum payType : values()) {
if (payType.code == code) {
return payType;
}
}
return null;
}
}
public class PaymentService {
public String processPayment(int payType) {
PayTypeEnum payTypeEnum = PayTypeEnum.getByCode(payType);
if (payTypeEnum == null) {
return "不支持的支付方式";
}
return payTypeEnum.process();
}
}
简化三元表达式
当三元表达式嵌套层级过多时，可读性会大幅下降，此时可以通过提取变量或者拆分逻辑来简化。
优化前的代码：
public class ScoreService {
public String getScoreLevel(int score) {
return score >= 90 ? "优秀" : (score >= 80 ? "良好" : (score >= 60 ? "及格" : "不及格"));
}
}
优化后的代码：
public class ScoreService {
public String getScoreLevel(int score) {
if (score >= 90) {
return "优秀";
} else if (score >= 80) {
return "良好";
} else if (score >= 60) {
return "及格";
} else {
return "不及格";
}
}
}
总结
简化Java条件表达式的核心是提升代码的可读性和可维护性，不同的场景适合不同的优化方式。提取布尔变量适合复杂逻辑组合的场景，卫语句适合多异常分支的场景，合并重复分支可以减少冗余代码，枚举适合固定值多分支的场景。开发者可以根据实际的业务场景选择合适的优化方式，让代码更简洁高效。