前言
日常开发中if...else...一定是我们经常使用到操作语法，一般而言，少量的if...else...是不会产生什么影响的，但现实是，由于复杂的业务逻辑以及开发人员技能的参差不齐，往往会充斥着大量的、多层嵌套的if...else...，这会非常影响代码的阅读性和维护性。
接下来，我们来看看都有哪些方式可以减少if...else...的出现
1. 卫语句
卫语句可以减少嵌套，也就减少了层次的缩进，代码的复杂度，这样在阅读理解上会更加轻松。
优化前的方式
public void test() {
if(条件1成立){
if(条件2成立){
执行xxx逻辑;
}
}
}
优化后减少了嵌套
public void test() {
if(!条件1成立){
return;
}
if(!条件2成立){
return;
}
执行xxx逻辑;
}
2. 去else
优化前
public void test() {
if (10 < amount && amount < 20) {
执行xxx逻辑;
} else if (21 < amount && amount < 30) {
执行xxx逻辑;
} else if (31 < amount && amount < 40) {
执行xxx逻辑;
} else {
执行xxx逻辑;
}
}
优化后
public void test1() {
if (10 < amount && amount < 20) {
执行xxx逻辑;
return;
}
if (21 < amount && amount < 30) {
执行xxx逻辑;
return;
}
if (31 < amount && amount < 40) {
执行xxx逻辑;
return;
}
执行xxx逻辑;
}
同样，代码看起来更加简洁。
3. 策略模式
策略模式也是经典的消除if...else...的手段。
下面这段逻辑描述的是，如果memberAttr是VIP，我们就根据用户VIP级别给到不同的折扣。
public BigDecimal test(String memberAttr) {
BigDecimal amount = BigDecimal.valueOf(10d);
if ("VIP".equals(memberAttr)) {
String level = getVipLevel();
if ("1".equals(level)) {
return amount.multiply(BigDecimal.valueOf(0.9));
}
if ("2".equals(level)) {
return amount.multiply(BigDecimal.valueOf(0.8));
}
return amount.multiply(BigDecimal.valueOf(0.7));
}
return amount;
}
对比使用卫语句进行优化
public BigDecimal test(String memberAttr, String userId) {
BigDecimal amount = BigDecimal.valueOf(10d);
if (!"VIP".equals(memberAttr)) {
return amount;
}
String level = getVipLevel(userId);
if ("1".equals(level)) {
amount = amount.multiply(BigDecimal.valueOf(0.9));
} else if ("2".equals(level)) {
amount = amount.multiply(BigDecimal.valueOf(0.8));
} else {
amount = amount.multiply(BigDecimal.valueOf(0.7));
}
return amount;
}
去else优化
public BigDecimal test(String memberAttr, String userId) {
BigDecimal amount = BigDecimal.valueOf(10d);
if (!"VIP".equals(memberAttr)) {
return amount;
}
String level = getVipLevel(userId);
if ("1".equals(level)) {
return amount.multiply(BigDecimal.valueOf(0.9));
}
if ("2".equals(level)) {
return amount.multiply(BigDecimal.valueOf(0.8));
}
return amount.multiply(BigDecimal.valueOf(0.7));
}
最后是策略模式
public BigDecimal method1(String memberAttr, String userId) {
BigDecimal amount = BigDecimal.valueOf(10d);
if (!"VIP".equals(memberAttr)) {
return amount;
}
String level = getVipLevel(userId);
DiscountStrategy discountStrategy = DiscountStrategyFactory.getDiscountStrategy(level);
return discountStrategy.discount(amount);
}
4. switch
switch其实就是if...else...的一种简化写法，在语法上进行了优化，但要注意如果switch的条件出现在过多的业务场景中，那么可能就需要优化了。
前面的逻辑，换成switch
public BigDecimal test(String memberAttr, String userId) {
BigDecimal amount = BigDecimal.valueOf(10d);
if (!"VIP".equals(memberAttr)) {
return amount;
}
String level = getVipLevel(userId);
switch (level) {
case "1":
return amount.multiply(BigDecimal.valueOf(0.9));
case "2":
return amount.multiply(BigDecimal.valueOf(0.8));
default:
return amount.multiply(BigDecimal.valueOf(0.7));
}
}
5. Function函数式接口
Function函数式接口是JDK8提供的新特性，其使用非常灵活，借助它也可以帮助我们消灭if...else...
函数式接口主要分为四种：
- Supplier供给型函数
- Consumer消费型函数
- Runnable无参无返回型函数
- Function有参有返回型函数
具体每种接口类型不是本文讲解的重点，因此就不过多介绍了，我们直接来看看如何来优化if...else...的。
常规处理方式
public class FunctionTest {
public static void main(String[] args) {
commonMethod();
}
private static void commonMethod() {
if (checkXXX()) {
doSomething("commonMethod");
} else {
throw new RuntimeException("校验不通过！");
}
}
private static void doSomething(String str) {
System.out.println(str + ": doSomething....");
}
private static boolean checkXXX() {
return true;
}
}
使用function后
首先新增一个function接口
@FunctionalInterface
public interface MyExceptionFunction {
void throwException(String message);
}
再新增一个处理类
public class ExceptionUtils {
public static MyExceptionFunction isTrue(boolean isTrue) {
return (message -> {
if (!isTrue) {
throw new RuntimeException(message);
}
});
}
}
最后对比functionMethod方法的方式
public class FunctionTest {
public static void main(String[] args) {
commonMethod();
functionMethod();
}
private static void functionMethod() {
ExceptionUtils.isTrue(checkXXX()).throwException("校验不通过！");
doSomething("functionMethod");
}
private static void commonMethod() {
if (checkXXX()) {
doSomething("commonMethod");
} else {
throw new RuntimeException("校验不通过！");
}
}
private static void doSomething(String str) {
System.out.println(str + ": doSomething....");
}
private static boolean checkXXX() {
return true;
}
}
如果else也存在业务处理逻辑，则可以改成Runnable方式
定义function接口，接收两个Runnable型入参
@FunctionalInterface
public interface BranchHandleFunction {
void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);
}
public class BranchHandleUtils {
public static BranchHandleFunction isTrueOrFalse(boolean isTrue) {
return ((trueHandle, falseHandle) -> {
if (isTrue) {
trueHandle.run();
} else {
falseHandle.run();
}
});
}
}
public class FunctionTest {
public static void main(String[] args) {
branchHandleMethod();
}
private static void branchHandleMethod() {
BranchHandleUtils.isTrueOrFalse(checkXXX()).trueOrFalseHandle(() -> doSomething("true"), FunctionTest::doOther);
}
private static void doSomething(String str) {
System.out.println(str + ": doSomething....");
}
private static void doOther() {
System.out.println("doOther....");
}
private static boolean checkXXX() {
return true;
}
}
还有针对参数有处理逻辑的，还可以使用消费型函数
@FunctionalInterface
public interface ConsumerFunction<T extends Object> {
void consumeHandle(Consumer<? super T> consumer, Runnable runnable);
}
public class ConsumerFunctionUtils {
public static ConsumerFunction<String> isNullOrEmpty(String param) {
return (consumer, runnable) -> {
if (Strings.isNullOrEmpty(param)) {
runnable.run();
} else {
consumer.accept(param);
}
};
}
}
public class FunctionTest {
public static void main(String[] args) {
consumeHandleMethod();
}
private static void consumeHandleMethod() {
ConsumerFunctionUtils.isNullOrEmpty("abc").consumeHandle(FunctionTest::doSomething, FunctionTest::doOther);
}
private static void doSomething(String str) {
System.out.println(str + ": doSomething....");
}
private static void doOther() {
System.out.println("doOther....");
}
}
函数式接口功能强大且灵活，可以借助它来消除业务代码中的if...else....，但同时也会新增许多接口和类，如果业务逻辑本身非常简单，却要使用函数式接口来处理，可能得不偿失。
总结
最后关于上面介绍的五种方式，希望大家能够结合实际场景灵活运用，切勿生搬硬套，方可写出优雅的代码。