去掉满屏if语句，让代码干净清爽

桃扇骨 2024-03-16 10:35 28阅读 0赞

当你看到满屏得if，是不是感觉天旋地转，怀疑人生，其实我们在编写 Java 代码时，有几种方法是可以减少 if 语句的使用，提高代码的可读性和可维护性。下面列举了几种常用的方法：

1.  使用多态：通过使用面向对象的多态特性，可以将不同的逻辑封装到不同的类中，避免大量的 if  
    语句。使用继承和接口来定义通用的方法，并让具体的实现类实现这些方法。
2.  使用设计模式：使用设计模式可以更好地组织和管理代码逻辑，减少 if  
    语句的使用。例如，工厂模式、策略模式、观察者模式等都可以帮助将复杂的条件逻辑转化为更清晰和可扩展的结构。
3.  使用映射表：将条件与对应的操作放入一个映射表中，避免使用大量的 if-else 语句。可以使用 Map  
    或者其他数据结构来存储条件和对应操作的关联关系，通过查找映射表获取对应的操作。
4.  使用策略模式：策略模式将不同的策略封装成独立的类，避免使用大量的条件语句。通过定义一个策略接口，然后针对不同的情况实现不同的策略类，根据需要选择合适的策略进行处理。
5.  使用枚举：使用枚举可以将条件与对应的操作封装到枚举常量中，避免使用大量的 if-else  
    语句。每个枚举常量代表一种情况，具有对应的方法或行为，通过枚举常量的方式来执行相应的操作。
6.  使用函数式编程：Java 8 引入的函数式编程特性可以帮助减少条件判断。通过使用 lambda  
    表达式、方法引用等函数式编程的特性，可以将逻辑封装成函数并传递，避免大量的 if-else 语句。

当然，还有不太常见的几种方法：

1.  使用断言（Assertions）：通过使用断言来确保某些条件满足，可以避免使用大量的条件判断。断言通常在开发和调试阶段使用，可以在代码中插入断言语句来验证前置条件，如果条件不满足，则会抛出异常。
2.  使用状态模式：状态模式允许对象在内部状态改变时改变其行为，从而避免了大量的条件判断。通过定义不同的状态类，并在对象内部维护当前状态，可以根据状态来执行相应的操作，而无需使用大量的  
    if-else 语句。
3.  使用规则引擎：规则引擎是一种基于规则的编程模型，通过将条件和相应的操作定义为规则，可以避免使用大量的条件判断。规则引擎提供了一种声明性的方式来描述和执行条件逻辑，使代码更易读、扩展和维护。
4.  使用函数重载：函数重载允许在同一个类中定义多个同名但参数列表不同的方法。通过使用函数重载，可以根据不同的参数类型或数量来调用不同的方法，而无需使用条件判断来确定具体的操作。
5.  使用表达式语言：在某些情况下，可以使用表达式语言来处理条件逻辑，避免使用大量的条件判断。例如，在使用规则引擎或动态查询时，可以使用表达式语言来定义和执行条件表达式。

##### 以下是一个使用多态的示例代码： #####

abstract class Shape {
        abstract void draw();
    }
    
    class Rectangle extends Shape {
        @Override
        void draw() {
            System.out.println("Drawing a rectangle");
        }
    }
    
    class Circle extends Shape {
        @Override
        void draw() {
            System.out.println("Drawing a circle");
        }
    }
    
    class Triangle extends Shape {
        @Override
        void draw() {
            System.out.println("Drawing a triangle");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Shape rectangle = new Rectangle();
            Shape circle = new Circle();
            Shape triangle = new Triangle();
    
            drawShape(rectangle); // 调用多态方法，输出：Drawing a rectangle
            drawShape(circle);    // 调用多态方法，输出：Drawing a circle
            drawShape(triangle);  // 调用多态方法，输出：Drawing a triangle
        }
    
        static void drawShape(Shape shape) {
            shape.draw();
        }
    }

在上述示例中，我们定义了一个抽象类 Shape，它有一个抽象方法 draw()。然后我们创建了 Rectangle、Circle 和 Triangle 这三个具体的子类，它们分别继承自 Shape 并实现了 draw() 方法。

在 Main 类中，我们定义了一个静态方法 drawShape()，它的参数是 Shape 类型。这个方法利用多态，可以接受任意子类对象作为参数，并调用相应的 draw() 方法。这样，我们可以通过调用 drawShape() 方法来绘制不同的形状，而不需要使用大量的 if 语句判断具体的形状类型。

通过使用多态，我们将具体的形状对象都当作 Shape 类型来处理，根据实际对象的类型，动态地调用相应的 draw() 方法。这样可以避免大量的 if 语句，使代码更加简洁、可扩展和可维护。

##### 下面是两个常用的设计模式示例代码，分别是策略模式和工厂模式： #####

**策略模式示例代码：**

interface PaymentStrategy {
        void pay(double amount);
    }
    
    class CreditCardPayment implements PaymentStrategy {
        @Override
        public void pay(double amount) {
            System.out.println("Paid " + amount + " using Credit Card");
        }
    }
    
    class PayPalPayment implements PaymentStrategy {
        @Override
        public void pay(double amount) {
            System.out.println("Paid " + amount + " using PayPal");
        }
    }
    
    class PaymentContext {
        private PaymentStrategy paymentStrategy;
    
        public PaymentContext(PaymentStrategy paymentStrategy) {
            this.paymentStrategy = paymentStrategy;
        }
    
        public void performPayment(double amount) {
            paymentStrategy.pay(amount);
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            PaymentContext paymentContext1 = new PaymentContext(new CreditCardPayment());
            paymentContext1.performPayment(100.0); // 输出：Paid 100.0 using Credit Card
    
            PaymentContext paymentContext2 = new PaymentContext(new PayPalPayment());
            paymentContext2.performPayment(50.0); // 输出：Paid 50.0 using PayPal
        }
    }

在上述示例中，定义了一个支付策略接口 PaymentStrategy，并有两个实现类 CreditCardPayment 和 PayPalPayment，分别表示使用信用卡和PayPal进行支付。

PaymentContext 类是策略模式的上下文，持有一个支付策略对象，通过构造函数注入具体的支付策略。performPayment() 方法用于执行支付操作，实际调用的是具体支付策略对象的 pay() 方法。

通过使用策略模式，我们将不同的支付方式封装成不同的策略类，而不是通过大量的 if 语句来判断具体的支付方式。通过将支付策略对象传递给上下文对象，实现了动态选择和执行支付策略的功能。

**工厂模式示例代码：**

interface Shape {
        void draw();
    }
    
    class Rectangle implements Shape {
        @Override
        public void draw() {
            System.out.println("Drawing a rectangle");
        }
    }
    
    class Circle implements Shape {
        @Override
        public void draw() {
            System.out.println("Drawing a circle");
        }
    }
    
    class ShapeFactory {
        public static Shape createShape(String shapeType) {
            if (shapeType.equalsIgnoreCase("rectangle")) {
                return new Rectangle();
            } else if (shapeType.equalsIgnoreCase("circle")) {
                return new Circle();
            }
            return null;
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Shape rectangle = ShapeFactory.createShape("rectangle");
            if (rectangle != null) {
                rectangle.draw(); // 输出：Drawing a rectangle
            }
    
            Shape circle = ShapeFactory.createShape("circle");
            if (circle != null) {
                circle.draw(); // 输出：Drawing a circle
            }
        }
    }

在上述示例中，定义了一个形状接口 Shape，并有两个实现类 Rectangle 和 Circle，分别表示

##### 以下是使用映射表解决 if 问题的示例代码： #####

import java.util.HashMap;
    import java.util.Map;
    
    public class Main {
        public static void main(String[] args) {
            // 创建映射表，将条件和对应的处理逻辑关联起来
            Map<String, Runnable> actionMap = new HashMap<>();
            actionMap.put("condition1", () -> {
                // 处理条件1的逻辑
                System.out.println("Condition 1 is met");
            });
            actionMap.put("condition2", () -> {
                // 处理条件2的逻辑
                System.out.println("Condition 2 is met");
            });
    
            // 模拟根据条件选择处理逻辑
            String condition = "condition2";
            if (actionMap.containsKey(condition)) {
                // 根据条件获取对应的处理逻辑，并执行
                actionMap.get(condition).run();
            } else {
                // 处理无效条件
                System.out.println("Invalid condition: " + condition);
            }
        }
    }

在上述示例中，我们创建了一个 actionMap 映射表，将不同条件和对应的处理逻辑关联起来。这里使用 Runnable 函数式接口来定义逻辑操作。

通过调用 put() 方法，我们将不同条件和对应的处理逻辑添加到映射表中。在主程序中，我们指定要处理的条件（condition）。

然后，我们通过判断映射表中是否包含指定的条件，如果包含，则从映射表中获取对应的处理逻辑，并通过调用 run() 方法来执行该逻辑。如果映射表中不包含指定的条件，则输出无效条件的提示信息。

##### 使用枚举 解决if问题 具体示例代码 #####

使用枚举可以有效地解决 if 问题，下面是一个使用枚举解决 if 问题的示例代码：

enum Condition {
        CONDITION_1,
        CONDITION_2
    }
    
    interface Action {
        void execute();
    }
    
    class Condition1Action implements Action {
        @Override
        public void execute() {
            // 处理条件1的逻辑
            System.out.println("Condition 1 is met");
        }
    }
    
    class Condition2Action implements Action {
        @Override
        public void execute() {
            // 处理条件2的逻辑
            System.out.println("Condition 2 is met");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Condition condition = Condition.CONDITION_2;
    
            switch (condition) {
                case CONDITION_1:
                    new Condition1Action().execute();
                    break;
                case CONDITION_2:
                    new Condition2Action().execute();
                    break;
                default:
                    System.out.println("Invalid condition: " + condition);
            }
        }
    }

在上述示例中，我们定义了一个枚举 Condition，其中包含了不同的条件值。接着，我们创建了一个 Action 接口，用于定义处理逻辑的执行方法。

然后，我们定义了具体的实现类 Condition1Action 和 Condition2Action，分别对应不同条件的处理逻辑。

在主程序中，我们指定要处理的条件（condition）。通过使用 switch 语句，根据条件的枚举值选择对应的处理逻辑，并进行执行。

使用枚举可以将不同条件和对应的处理逻辑封装在一起，避免了使用大量的 if 语句。枚举提供了更加直观和可读的方式来表示条件，并且可以轻松地扩展和维护代码

**与使用 if 语句相比，使用枚举和 switch 语句有以下几点区别：**

*  可读性：使用枚举可以提高代码的可读性。枚举常量具有清晰的语义，可以直观地表示不同的条件。在 switch  
    语句中，通过枚举常量来区分不同的条件，代码逻辑更加清晰明了。
 *  可扩展性：使用枚举和 switch 语句的组合可以方便地扩展和维护代码。如果需要添加新的条件，只需在枚举中添加新的常量，并在 switch语句中添加相应的逻辑处理即可，不需要修改其他部分的代码。
 *  类型安全：枚举常量是类型安全的，编译器会检查枚举常量是否在 switch 语句中全部处理，从而避免遗漏条件的情况。而使用 if语句时，条件判断可能会存在遗漏或重复的情况。
 *  性能：在某些情况下，使用 switch 语句可能比使用一系列的 if-else 语句执行效率更高，因为 switch语句可以进行优化。但是，性能的影响因具体情况而异，具体取决于编译器和运行时环境。

##### 使用函数式编程 解决if问题，具体示例代码 #####

使用函数式编程的方式可以简化对条件判断的处理，以下是一个使用函数式编程解决 if 问题的示例代码：

import java.util.HashMap;
    import java.util.Map;
    import java.util.function.Consumer;
    
    public class Main {
        public static void main(String[] args) {
            Map<String, Consumer<String>> actionMap = new HashMap<>();
            actionMap.put("condition1", Main::handleCondition1);
            actionMap.put("condition2", Main::handleCondition2);
    
            String condition = "condition2";
            actionMap.getOrDefault(condition, Main::handleInvalidCondition).accept(condition);
        }
    
        private static void handleCondition1(String condition) {
            // 处理条件1的逻辑
            System.out.println("Condition 1 is met");
        }
    
        private static void handleCondition2(String condition) {
            // 处理条件2的逻辑
            System.out.println("Condition 2 is met");
        }
    
        private static void handleInvalidCondition(String condition) {
            // 处理无效条件
            System.out.println("Invalid condition: " + condition);
        }
    }

在上述示例中，我们使用了 java.util.function.Consumer 函数式接口来表示条件对应的处理逻辑。通过 Map 数据结构，将条件和对应的处理逻辑进行关联。

在主程序中，我们指定要处理的条件（condition）。通过调用 getOrDefault() 方法，根据条件获取对应的处理逻辑（使用方法引用 Main::handleCondition1 和 Main::handleCondition2），如果条件不存在于映射表中，则使用 Main::handleInvalidCondition 来处理无效条件。

通过调用 accept() 方法，将条件传递给对应的处理逻辑，从而实现了条件判断的处理。

使用函数式编程可以将条件判断的逻辑封装在函数接口中，通过函数的组合和传递，可以使代码更加简洁和易于维护。函数式编程提供了一种声明式的方式来处理条件判断，而不是通过大量的 if-else 语句来处理不同的情况。