2024年C C++最全去掉 if(1)，作为程序员一定不要仅仅追求物质

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

private String statusDes;

static OrderStatusEnum of(String status) {
    for (OrderStatusEnum statusEnum : OrderStatusEnum.values()) {
        if (statusEnum.getStatus().equals(status)) {
            return statusEnum;
        }
    }
    return null;
}

}

有了这个枚举，上面代码直接可以优化为一行代码：

String orderStatusDes = OrderStatusEnum.of(orderStatus).getStatusDes();

当然一般在实际项目中，这种处理方式也不是最佳的，最佳的方式应该是在数据库里面有一个码值配置表，然后加载到系统缓存中来，在通过 code 去取值。当然枚举也是一种很好的解决方案。


### 方案三：Optional 判空


我相信各位小伙伴的项目里面一定存在非空判断，如果为空，则抛出异常或者 return。

Order order = getOrderById(id);
if (order == null) {
return “-1”;
} else {
return order.getOrderStatus();
}

对于这种代码我们利用 Optional 可以非常优雅地解决。

return Optional.ofNullable(order).map(o -> o.getOrderStatus()).orElse(“-1”);

 


这种方式是不是非常优雅，有格调。最后补充一句：



> 
> **防止 NPE，是程序员的基本修养**
> 
> 
> 


 


### 方案四：表驱动法


表驱动法，是一种让你可以在表中查找信息，而不必用过多的 if...else 来把他们找出来的方法。如下：

if (“code1”.equals(action)) {
doAction1();
} else if (“code2”.equals(action)) {
doAction2();
} else if (“code3”.equals(action)) {
doAction3();
} else if (“code4”.equals(action)) {
doAction4();
} else if (“code5”.equals(action)) {
doAction5();
}

优化方法如下：

Map<String, Function<?> action> actionMap = new HashMap<>();
action.put(“code1”,() -> {doAction1()});
action.put(“code2”,() -> {doAction2()});
action.put(“code3”,() -> {doAction3()});
action.put(“code4”,() -> {doAction4()});
action.put(“code5”,() -> {doAction5()});

// 使用
actionMap.get(action).apply();

其实这种方式也不是很好，因为它会显得代码非常臃肿。一种变形方案是将 `doAction()` 抽象成类。如下：

//1. 先定义一个 ActionService 接口
public interface ActionService {
void doAction();
}

//2. 然后定义 5 个实现类
public class ActionService1 implements ActionService{
public void doAction() {
//do something
}
}

//3. 加入表中
Map<String, ActionService> actionMap = new HashMap<>();
action.put(“code1”,new ActionService1());
action.put(“code2”,new ActionService2());
action.put(“code3”,new ActionService3());
action.put(“code4”,new ActionService4());
action.put(“code5”,new ActionService5());

//4. 调用
actionMap.get(action).doAction();

这种方式是不是比较优雅些！


### 方案五：策略模式 + 工厂方法


策略模式 + 工厂方法是解决 if...else 用得非常多的方案，它和上面的表驱动法有点儿类似。使用策略模式 + 工厂方法分为几个步骤，以上面例子为例：


* **把条件模块抽象为一个公共的接口，策略接口**

public interface ActionService {
void doAction();
}

* **根据每个逻辑，定义出自己具体的策略实现类**，如下：

public class ActionService1 implements ActionService{
public void doAction() {
//do something
}
}

public class ActionService2 implements ActionService{
public void doAction() {
//do something
}
}

// 省略其他策略

* **工厂类，统一调度，用来管理这些策略**，如下：

public class ActionServiceFactory {
private ActionServiceFactory(){

}

private static class SingletonHolder{
    private static ActionServiceFactory instance=new ActionServiceFactory();
}

public static ActionServiceFactory getInstance(){
    return SingletonHolder.instance;
}

private static final Map<String,ActionService> ACTION_SERVICE_MAP = new HashMap<String, ActionService>();

static {
    ACTION_SERVICE_MAP.put("action1",new ActionService1());
    ACTION_SERVICE_MAP.put("action2",new ActionService2());
    ACTION_SERVICE_MAP.put("action3",new ActionService3());
    ACTION_SERVICE_MAP.put("action4",new ActionService4());
    ACTION_SERVICE_MAP.put("action5",new ActionService5());
}

public static ActionService getActionService(String actionCode) {
    ActionService actionService = ACTION_SERVICE_MAP.get(actionCode);
    if (actionService == null) {
        throw new RuntimeException("非法 actionCode");
    }
    return actionService;
}

public void doAction(String actionCode) {
    getActionService(actionCode).doAction();
}

}

单例模式实现工厂类。


* **使用**

ActionServiceFactory.getInstance().doAction(“action1”);

这种优化方式也是很优雅的，特别适合分支较多，逻辑较为复杂的代码块，这种方式将分支逻辑与业务代码解耦了，是一种很不错的方案。


### 方案六：责任链模式


你想不到责任链模式也能优化 if...else 吧。责任链我们可以看做是一个单链表的数据结构，一个对象一个对象地过滤条件，符合的就执行，然后结束，不符合的就传递到下一个节点，如果每个对象都无法处理，一般都有一个最终的节点来统一处理。


我们依然以上面那个例子为例。


* **定义责任链处理请求节点**

public abstract class ActionHandler {

// 后继节点
protected ActionHandler successor;

/**
 * 处理请求
 * @param actionCode
 */
public void handler(String actionCode) {
    doHandler(actionCode);
}

// 设置后继节点
protected ActionHandler setSuccessor(ActionHandler successor) {
    this.successor = successor;
    return this;
}

// 处理请求
public abstract void doHandler(String actionCode);

}

* **定义首尾节点，用于一些异常情况的处理**

// 首节点，判断 actionCode 是否为空
public class HeadHandler extends ActionHandler{

@Override
public void doHandler(String actionCode) {
    if (StringUtils.isBlank(actionCode)) {
        throw new RuntimeException("actionCode 不能为空");
    }

    successor.doHandler(actionCode);
}

}

// 尾节点，直接抛出异常，因为到了尾节点说明当前 code 没有处理
public class TailHandler extends ActionHandler{

@Override
public void doHandler(String actionCode) {
    throw new RuntimeException("当前 code[" + actionCode + "] 没有具体的 Handler 处理");
}

}

* **定义各个节点具体的实现节点**

public class ActionHandler1 extends ActionHandler{

@Override
public void doHandler(String actionCode) {
    if ("action1".equals(actionCode)) {
        doAction1();
    } else {
        // 传递到下一个节点
        successor.doHandler(actionCode);
    }
}

}

public class ActionHandler2 extends ActionHandler{

@Override
public void doHandler(String actionCode) {
    if ("action2".equals(actionCode)) {
        doAction2();
    } else {
        // 传递到下一个节点
        successor.doHandler(actionCode);
    }
}

}

// 省略其他节点

* **定义工厂，来构建一条完整的责任链，并负责调度**

public class ActionHandlerFactory {

private ActionHandler headHandler;

private ActionHandlerFactory(){
    headHandler = new HeadHandler();
    ActionHandler actionHandler1 = new ActionHandler1();
    ActionHandler actionHandler2 = new ActionHandler2();
    ActionHandler actionHandler3 = new ActionHandler3();
    ActionHandler actionHandler4 = new ActionHandler4();
    ActionHandler actionHandler5 = new ActionHandler5();

    ActionHandler tailHandler = new TailHandler();
    
    // 构建一条完整的责任链
    headHandler.setSuccessor(actionHandler1).setSuccessor(actionHandler2).setSuccessor(actionHandler3).
            setSuccessor(actionHandler4).setSuccessor(actionHandler5).setSuccessor(tailHandler);
}

private static class SingletonHolder{
    private static ActionHandlerFactory instance=new ActionHandlerFactory();
}

public static ActionHandlerFactory getInstance(){
    return SingletonHolder.instance;
}
    
public void doAction(String actionCode) {
    headHandler.doHandler(actionCode);
}

}

* **使用**

ActionHandlerFactory.getInstance().doAction(“action1”);

 


### 方案七：Function


![img](https://img-blog.csdnimg.cn/img_convert/6a49d8b25f1c54cac63898f9edac2ae2.png)
![img](https://img-blog.csdnimg.cn/img_convert/8b2b8471d94911db4c36ea1a14d0fbb4.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**


* **使用**

ActionHandlerFactory.getInstance().doAction(“action1”);

 


### 方案七：Function


[外链图片转存中...(img-POH0aRBA-1715537967332)]
[外链图片转存中...(img-4Hxv9cDa-1715537967333)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[如果你需要这些资料，可以戳这里获取](https://bbs.csdn.net/topics/618668825)**