如何 Java 中的大量的 if else 判断？

骑猪看日落 2024-03-16 18:36 86阅读 0赞

**目录**

问题出现：

解决方案：

1.策略模式

2.工厂模式

3.映射表

4.反射+配置文件------极力推荐使用！！！！！

--------------------

## 问题出现： ##

### 如何 Java 中的大量的 if else 判断？ ###

在编写Java相关程序时，我们经常遇到：

![a3ff92175cdc460089d22169e14bbe86.png][]

大量的 if else 语句，无不让人内心疯狂，这都是些啥代码啊！！！！！！一点编程艺术的没有，简称：烂代码！

如果学习过设计模式，那应该没问题了。

### 解决方案： ###

在 Java 中，有多种方式可以避免大量的 if-else 判断。下面列举一些常用的方法和相关案例：

#### 1.策略模式 ####

策略模式是一种行为型设计模式，它通过定义一系列算法类（策略类），将算法的实现与使用分离开来，使得算法可以独立于使用它的客户端而变化。在 Java 中，策略模式通常被应用于业务逻辑中，用于处理不同的业务场景和业务规则。具体实现如下：

首先，定义一个策略接口或抽象类，用于封装具体的算法：

public interface Strategy {
        void execute();
    }

然后，定义多个具体的策略类，实现该接口或抽象类：

public class ConcreteStrategyA implements Strategy {
        @Override
        public void execute() {
            // 实现具体的算法 A
        }
    }
    
    public class ConcreteStrategyB implements Strategy {
        @Override
        public void execute() {
            // 实现具体的算法 B
        }
    }
    
    public class ConcreteStrategyC implements Strategy {
        @Override
        public void execute() {
            // 实现具体的算法 C
        }
    }

接着，定义一个上下文类，用于管理所有的策略：

public class Context {
        private Strategy strategy;
    
        public Context(Strategy strategy) {
            this.strategy = strategy;
        }
    
        public void executeStrategy() {
            strategy.execute();
        }
    }

最后，在客户端中，根据业务需要，传入相应的策略对象，执行对应的算法：

Strategy strategy = new ConcreteStrategyA(); // or new ConcreteStrategyB() 或者new ConcreteStrategyC()
    Context context = new Context(strategy);
    context.executeStrategy();

#### 2.工厂模式 ####

工厂模式是一种创建型设计模式，它通过定义一个工厂类来封装对象的创建过程，从而将客户端代码与具体的产品实现解耦。在 Java 中，工厂模式通常被应用于对象的创建和组装场景中。具体实现如下：

首先，定义一个产品接口或抽象类，用于封装产品的通用接口或抽象父类：

public interface Product {
        void method();
    }

然后，定义多个具体的产品类，实现该接口或抽象父类：

public class ConcreteProductA implements Product {
        @Override
        public void method() {
            // 实现具体的产品 A 的方法
        }
    }
    
    public class ConcreteProductB implements Product {
        @Override
        public void method() {
            // 实现具体的产品 B 的方法
        }
    }
    
    public class ConcreteProductC implements Product {
        @Override
        public void method() {
            // 实现具体的产品 C 的方法
        }
    }

接着，定义一个工厂类，用于创建产品对象：

public class Factory {
        public static Product create(String type) {
            switch (type) {
                case "A":
                    return new ConcreteProductA();
                case "B":
                    return new ConcreteProductB();
                case "C":
                    return new ConcreteProductC();
                default:
                    throw new IllegalArgumentException("Invalid type: " + type);
            }
        }
    }

最后，在客户端中，调用工厂类的静态方法，创建对应的产品对象：

Product product = Factory.create("A"); // or Factory.create("B") 或者Factory.create("C")
    product.method();

#### 3.映射表 ####

映射表是一种基于哈希表实现的数据结构，它可以将多个条件值（如字符串或枚举值）映射到对应的处理函数上。在 Java 中，通过使用 Map 数据结构，可以很方便地实现映射表。具体实现如下：

首先，创建一个 Map 对象，用于存储条件值和处理函数之间的映射关系：

Map<String, Runnable> map = new HashMap<>();

然后，将每个条件值和对应的处理函数注册到 Map 中：

map.put("value1", () -> {
        // 处理 value1 条件的逻辑
    });
    
    map.put("value2", () -> {
        // 处理 value2 条件的逻辑
    });
    
    // ...

最后，在客户端中，根据需要执行对应的处理函数：

String condition = "value1"; // or "value2" 或者其他条件值
    Runnable handler = map.get(condition);
    if (handler != null) {
        handler.run();
    } else {
        throw new IllegalArgumentException("Unsupported condition: " + condition);
    }

#### 4.反射+配置文件------极力推荐使用！！！！！ ####

可以看看这个：[http://t.csdn.cn/XJIpu][http_t.csdn.cn_XJIpu]

不知道反射？看这：-----》》》[http://t.csdn.cn/5sbcp][http_t.csdn.cn_5sbcp]

>  *  在 Java 中，if-else 语句通常用来处理不同的条件分支。虽然 if-else 语句很好用，但如果有大量的 if-else 分支，会降低程序的可读性、可维护性和可扩展性。当需要添加或删除某个条件分支时，需要修改相应的代码，这样容易引入新的错误或导致不必要的耦合。为了避免这些问题，可以使用反射和配置文件来解决大量的 if-else 判断。
>  *  反射是一种在运行时获取类信息和类实例，并通过这些信息和实例来调用类的方法或操作其属性的机制。Java 提供了一组反射 API，可以在运行时获取类的结构信息、创建类的实例、访问类的属性、调用类的方法等。使用反射机制可以将程序的控制流程动态化，不再依赖于编译时确定的类型和方法，从而提高了程序的灵活性和可扩展性。
>  *  配置文件是一种文本文件，用于保存程序的配置信息。Java 中的配置文件通常以 .properties 或 .xml 格式保存，其中 .properties 文件格式最简单，它由多个属性名和属性值组成，每个属性名和属性值之间使用等号（=）连接。使用配置文件可以将程序的配置信息从代码中分离出来，使得程序的配置更加灵活和易于管理。
> 
> 使用反射和配置文件来避免大量的 if-else 判断的实现步骤如下：

\--1.定义一个接口或抽象类，用于定义通用行为或方法。例如，定义一个接口 Action，用于执行某个动作：

public interface Action {
        void execute(String param1, String param2);
    }

\--2.定义多个实现该接口或抽象类的具体类，实现自己的业务逻辑。例如，定义两个实现类 ConcreteAction1 和 ConcreteAction2。

public class ConcreteAction1 implements Action {
        @Override
        public void execute(String param1, String param2) {
            // 处理 ConcreteAction1 业务逻辑
        }
    }
    
    public class ConcreteAction2 implements Action {
        @Override
        public void execute(String param1, String param2) {
            // 处理 ConcreteAction2 业务逻辑
        }
    }

\--3.将每个具体类的信息（包括类名、参数等）保存到配置文件中。例如，将上述两个类的信息保存到 config.properties 文件中。

action.1=com.example.ConcreteAction1
    action.2=com.example.ConcreteAction2

\--4.在程序启动时，读取配置文件，并通过反射机制创建具体类的实例。例如，读取 config.properties 文件中的属性，并创建 ConcreteAction1 的实例。

Properties props = new Properties();
    try (InputStream stream = getClass().getResourceAsStream("config.properties")) {
        props.load(stream);
    }
    
    String actionName = props.getProperty("action.1"); // 具体类的类名
    Class<?> actionClass = Class.forName(actionName);
    Action action = (Action) actionClass.getDeclaredConstructor().newInstance(); // 创建具体类的实例

\--5.在程序运行时，通过 Action 接口调用具体类的方法。例如，执行 ConcreteAction1 的 execute 方法，并传入参数。

action.execute("param1", "param2");

> 使用反射和配置文件来避免大量的 if-else 判断可以将程序的控制流程动态化，从而提高了程序的灵活性和可扩展性。当需要添加或删除某个条件分支时，只需要修改配置文件，而不需要修改代码。使用这种方式还可以将程序的配置信息和业务逻辑分离开来，使得程序更加易于管理和维护。

[a3ff92175cdc460089d22169e14bbe86.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/9f04d121a059420980c4b8a684bdcffe.png
[http_t.csdn.cn_XJIpu]: http://t.csdn.cn/XJIpu
[http_t.csdn.cn_5sbcp]: http://t.csdn.cn/5sbcp