Java决策树替代IF-ELSE解决多重判断

原创 于 2025-08-16 16:09:39 发布 · 459 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#决策树 #算法 #机器学习

前言

决策树是一种特殊的二叉树，每个节点与子节点相连的线都有对应的条件，通过条件判断来决定去往哪个子节点。

在项目中经常遇到判断性别+年龄+工资+住址+.....如果用if-else很容易乱套，此时可以通过决策树来解决多重判断问题。

用图来看的话就是这样子的结构

实现

首先设计决策树的结构，决策树包含了节点、节点之间的线、树根。为了实现低耦合高内聚我们奖决策树这个类单独分离出去。

// 规则树
public class TreeRoot {

    private Long treeId;         //规则树ID
    private Long treeRootNodeId; //规则树根ID
    private String treeName;     //规则树名称

    public Long getTreeId() {
        return treeId;
    }

    public void setTreeId(Long treeId) {
        this.treeId = treeId;
    }

    public Long getTreeRootNodeId() {
        return treeRootNodeId;
    }

    public void setTreeRootNodeId(Long treeRootNodeId) {
        this.treeRootNodeId = treeRootNodeId;
    }

    public String getTreeName() {
        return treeName;
    }

    public void setTreeName(String treeName) {
        this.treeName = treeName;
    }
}


// 规则树节点
public class TreeNode {

    private Long treeId;            //规则树ID
    private Long treeNodeId;        //规则树节点ID
    private Integer nodeType;       //节点类型；1子叶、2果实
    private String nodeValue;       //节点值[nodeType=2]；果实值
    private String ruleKey;         //规则Key
    private String ruleDesc;        //规则描述
    private List<TreeNodeLink> treeNodeLinkList; //节点链路

    public Long getTreeId() {
        return treeId;
    }

    public void setTreeId(Long treeId) {
        this.treeId = treeId;
    }

    public Long getTreeNodeId() {
        return treeNodeId;
    }

    public void setTreeNodeId(Long treeNodeId) {
        this.treeNodeId = treeNodeId;
    }

    public Integer getNodeType() {
        return nodeType;
    }

    public void setNodeType(Integer nodeType) {
        this.nodeType = nodeType;
    }

    public String getNodeValue() {
        return nodeValue;
    }

    public void setNodeValue(String nodeValue) {
        this.nodeValue = nodeValue;
    }

    public String getRuleKey() {
        return ruleKey;
    }

    public void setRuleKey(String ruleKey) {
        this.ruleKey = ruleKey;
    }

    public String getRuleDesc() {
        return ruleDesc;
    }

    public void setRuleDesc(String ruleDesc) {
        this.ruleDesc = ruleDesc;
    }

    public List<TreeNodeLink> getTreeNodeLinkList() {
        return treeNodeLinkList;
    }

    public void setTreeNodeLinkList(List<TreeNodeLink> treeNodeLinkList) {
        this.treeNodeLinkList = treeNodeLinkList;
    }

}


// 规则树线
public class TreeNodeLink {

    private Long nodeIdFrom;        //节点From
    private Long nodeIdTo;          //节点To
    private Integer ruleLimitType;  //限定类型；1:=;2:>;3:<;4:>=;5<=;6:enum[枚举范围]
    private String ruleLimitValue;  //限定值

    public Long getNodeIdFrom() {
        return nodeIdFrom;
    }

    public void setNodeIdFrom(Long nodeIdFrom) {
        this.nodeIdFrom = nodeIdFrom;
    }

    public Long getNodeIdTo() {
        return nodeIdTo;
    }

    public void setNodeIdTo(Long nodeIdTo) {
        this.nodeIdTo = nodeIdTo;
    }

    public Integer getRuleLimitType() {
        return ruleLimitType;
    }

    public void setRuleLimitType(Integer ruleLimitType) {
        this.ruleLimitType = ruleLimitType;
    }

    public String getRuleLimitValue() {
        return ruleLimitValue;
    }

    public void setRuleLimitValue(String ruleLimitValue) {
        this.ruleLimitValue = ruleLimitValue;
    }
}

// 规则树跟
public class TreeRoot {

    private Long treeId;         //规则树ID
    private Long treeRootNodeId; //规则树根ID
    private String treeName;     //规则树名称

    public Long getTreeId() {
        return treeId;
    }

    public void setTreeId(Long treeId) {
        this.treeId = treeId;
    }

    public Long getTreeRootNodeId() {
        return treeRootNodeId;
    }

    public void setTreeRootNodeId(Long treeRootNodeId) {
        this.treeRootNodeId = treeRootNodeId;
    }

    public String getTreeName() {
        return treeName;
    }

    public void setTreeName(String treeName) {
        this.treeName = treeName;
    }
}

这样决策树（规则树）的基本框架就搭建好了，为了实现查找的功能，还需要设计查找逻辑。

TreeNode 中的 规则Key 决定着需要比较哪个属性。

TreeNode 中的 规则处理器 决定使用哪个规则处理器。

TreeNode 中的 nodeValue 决定着该节点的值。

TreeNodeLink 中的 ruleLimitType 可以决定< > <= >= =等判断条件。

TreeNodeLink 中的 ruleLimitValue 可以决定与之判断的值。

通过上述的描述可以设计一个简单的比较逻辑。

首先设计一个比较接口。

public interface LogicFilter {

    /**
     * 逻辑决策器
     *
     * @param matterValue          决策值
     * @param treeNodeLineInfoList 决策节点
     * @return 下一个节点Id
     */
    Long filter(String matterValue, List<TreeNodeLink> treeNodeLineInfoList);

    /**
     * 获取决策值
     *
     * @param decisionMatter 决策物料
     * @return 决策值
     */
    String matterValue(Long treeId, String userId, Map<String, String> decisionMatter);

}

然后我们来实现这个接口。

public abstract class BaseLogic implements LogicFilter{

    @Override
    public Long filter(String matterValue, List<TreeNodeLink> treeNodeLinkList) {
        for (TreeNodeLink nodeLine : treeNodeLinkList) {
            if (decisionLogic(matterValue, nodeLine)) return nodeLine.getNodeIdTo();
        }
        return 0L;
    }

    @Override
    public abstract String matterValue(Long treeId, String userId, Map<String, String> decisionMatter);

    private boolean decisionLogic(String matterValue, TreeNodeLink nodeLink) {
        switch (nodeLink.getRuleLimitType()) {
            case 1:
                return matterValue.equals(nodeLink.getRuleLimitValue());
            case 2:
                return Double.parseDouble(matterValue) > Double.parseDouble(nodeLink.getRuleLimitValue());
            case 3:
                return Double.parseDouble(matterValue) < Double.parseDouble(nodeLink.getRuleLimitValue());
            case 4:
                return Double.parseDouble(matterValue) <= Double.parseDouble(nodeLink.getRuleLimitValue());
            case 5:
                return Double.parseDouble(matterValue) >= Double.parseDouble(nodeLink.getRuleLimitValue());
            default:
                return false;
        }
    }

}

通过这种方式可以实现基本的判断功能，但是并未实现指定值的对比，这还并不完善。接下来在增加规则处理器。

// 年龄处理器
public class UserAgeFilter extends BaseLogic {

    @Override
    public String matterValue(Long treeId, String userId, Map<String, String> decisionMatter) {
        return decisionMatter.get("age");
    }

}

// 性别处理器
public class UserGenderFilter extends BaseLogic {

    @Override
    public String matterValue(Long treeId, String userId, Map<String, String> decisionMatter) {
        return decisionMatter.get("gender");
    }

}

有了规则处理器，离实现代码只差一步之遥，还需要设计一个引擎将我们之前提到的各种属性串联起来。

// 引擎接口
public interface IEngine {

    EngineResult process(final Long treeId, final String userId, TreeRich treeRich, final Map<String, String> decisionMatter);

}


// 引擎配置
public class EngineConfig {

    static Map<String, LogicFilter> logicFilterMap;

    static { // 初始化规则处理器定义
        logicFilterMap = new ConcurrentHashMap<>();
        logicFilterMap.put("userAge", new UserAgeFilter());
        logicFilterMap.put("userGender", new UserGenderFilter());
    }

    public Map<String, LogicFilter> getLogicFilterMap() {
        return logicFilterMap;
    }

    public void setLogicFilterMap(Map<String, LogicFilter> logicFilterMap) {
        this.logicFilterMap = logicFilterMap;
    }

}


// 引擎框架
    public abstract class EngineBase extends EngineConfig implements IEngine{

        private Logger logger = LoggerFactory.getLogger(EngineBase.class);

        @Override
        public abstract EngineResult process(Long treeId, String userId, TreeRich treeRich, Map<String, String> decisionMatter);

        protected TreeNode engineDecisionMaker(TreeRich treeRich, Long treeId, String userId, Map<String, String> decisionMatter) {
            TreeRoot treeRoot = treeRich.getTreeRoot();
            Map<Long, TreeNode> treeNodeMap = treeRich.getTreeNodeMap();
            // 规则树根ID
            Long rootNodeId = treeRoot.getTreeRootNodeId();
            TreeNode treeNodeInfo = treeNodeMap.get(rootNodeId);
            //节点类型[NodeType]；1子叶、2果实
            while (treeNodeInfo.getNodeType().equals(1)) {
                String ruleKey = treeNodeInfo.getRuleKey();
                LogicFilter logicFilter = logicFilterMap.get(ruleKey);
                String matterValue = logicFilter.matterValue(treeId, userId, decisionMatter);
                Long nextNode = logicFilter.filter(matterValue, treeNodeInfo.getTreeNodeLinkList());
                treeNodeInfo = treeNodeMap.get(nextNode);
                logger.info("决策树引擎=>{} userId：{} treeId：{} treeNode：{} ruleKey：{} matterValue：{}", treeRoot.getTreeName(), userId, treeId, treeNodeInfo.getTreeNodeId(), ruleKey, matterValue);
            }
            return treeNodeInfo;
        }

    }


// 引擎实现
public class TreeEngineHandle extends EngineBase {

    @Override
    public EngineResult process(Long treeId, String userId, TreeRich treeRich, Map<String, String> decisionMatter) {
        // 决策流程
        TreeNode treeNode = engineDecisionMaker(treeRich, treeId, userId, decisionMatter);
        // 决策结果
        return new EngineResult(userId, treeId, treeNode.getTreeNodeId(), treeNode.getNodeValue());
    }

}

最后我们在设计一个决策结果类

public class EngineResult {

    private boolean isSuccess; //执行结果
    private String userId;     //用户ID
    private Long treeId;       //规则树ID
    private Long nodeId;       //果实节点ID
    private String nodeValue;  //果实节点值

    public EngineResult() {
    }

    public EngineResult(boolean isSuccess) {
        this.isSuccess = isSuccess;
    }

    public EngineResult(String userId, Long treeId, Long nodeId, String nodeValue) {
        this.isSuccess = true;
        this.userId = userId;
        this.treeId = treeId;
        this.nodeId = nodeId;
        this.nodeValue = nodeValue;
    }

    public boolean isSuccess() {
        return isSuccess;
    }

    public void setSuccess(boolean success) {
        isSuccess = success;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public Long getTreeId() {
        return treeId;
    }

    public void setTreeId(Long treeId) {
        this.treeId = treeId;
    }

    public Long getNodeId() {
        return nodeId;
    }

    public void setNodeId(Long nodeId) {
        this.nodeId = nodeId;
    }

    public String getNodeValue() {
        return nodeValue;
    }

    public void setNodeValue(String nodeValue) {
        this.nodeValue = nodeValue;
    }
}

最后一步就是填入数据以及测试

public class ApiTest {

    private Logger logger = LoggerFactory.getLogger(ApiTest.class);

    private TreeRich treeRich;

    @Before
    public void init(){
        // 节点：1
        TreeNode treeNode_01 = new TreeNode();
        treeNode_01.setTreeId(10001L);
        treeNode_01.setTreeNodeId(1L);
        treeNode_01.setNodeType(1);
        treeNode_01.setNodeValue(null);
        treeNode_01.setRuleKey("userGender");
        treeNode_01.setRuleDesc("用户性别[男/女]");

        // 链接：1->11
        TreeNodeLink treeNodeLink_11 = new TreeNodeLink();
        treeNodeLink_11.setNodeIdFrom(1L);
        treeNodeLink_11.setNodeIdTo(11L);
        treeNodeLink_11.setRuleLimitType(1);
        treeNodeLink_11.setRuleLimitValue("man");

        // 链接：1->12
        TreeNodeLink treeNodeLink_12 = new TreeNodeLink();
        treeNodeLink_12.setNodeIdFrom(1L);
        treeNodeLink_12.setNodeIdTo(12L);
        treeNodeLink_12.setRuleLimitType(1);
        treeNodeLink_12.setRuleLimitValue("woman");

        List<TreeNodeLink> treeNodeLinkList_1 = new ArrayList<>();
        treeNodeLinkList_1.add(treeNodeLink_11);
        treeNodeLinkList_1.add(treeNodeLink_12);

        treeNode_01.setTreeNodeLinkList(treeNodeLinkList_1);

        // 节点：11
        TreeNode treeNode_11 = new TreeNode();
        treeNode_11.setTreeId(10001L);
        treeNode_11.setTreeNodeId(11L);
        treeNode_11.setNodeType(1);
        treeNode_11.setNodeValue(null);
        treeNode_11.setRuleKey("userAge");
        treeNode_11.setRuleDesc("用户年龄");

        // 链接：11->111
        TreeNodeLink treeNodeLink_111 = new TreeNodeLink();
        treeNodeLink_111.setNodeIdFrom(11L);
        treeNodeLink_111.setNodeIdTo(111L);
        treeNodeLink_111.setRuleLimitType(3);
        treeNodeLink_111.setRuleLimitValue("25");

        // 链接：11->112
        TreeNodeLink treeNodeLink_112 = new TreeNodeLink();
        treeNodeLink_112.setNodeIdFrom(11L);
        treeNodeLink_112.setNodeIdTo(112L);
        treeNodeLink_112.setRuleLimitType(5);
        treeNodeLink_112.setRuleLimitValue("25");

        List<TreeNodeLink> treeNodeLinkList_11 = new ArrayList<>();
        treeNodeLinkList_11.add(treeNodeLink_111);
        treeNodeLinkList_11.add(treeNodeLink_112);

        treeNode_11.setTreeNodeLinkList(treeNodeLinkList_11);

        // 节点：12
        TreeNode treeNode_12 = new TreeNode();
        treeNode_12.setTreeId(10001L);
        treeNode_12.setTreeNodeId(12L);
        treeNode_12.setNodeType(1);
        treeNode_12.setNodeValue(null);
        treeNode_12.setRuleKey("userAge");
        treeNode_12.setRuleDesc("用户年龄");

        // 链接：12->121
        TreeNodeLink treeNodeLink_121 = new TreeNodeLink();
        treeNodeLink_121.setNodeIdFrom(12L);
        treeNodeLink_121.setNodeIdTo(121L);
        treeNodeLink_121.setRuleLimitType(3);
        treeNodeLink_121.setRuleLimitValue("25");

        // 链接：12->122
        TreeNodeLink treeNodeLink_122 = new TreeNodeLink();
        treeNodeLink_122.setNodeIdFrom(12L);
        treeNodeLink_122.setNodeIdTo(122L);
        treeNodeLink_122.setRuleLimitType(5);
        treeNodeLink_122.setRuleLimitValue("25");

        List<TreeNodeLink> treeNodeLinkList_12 = new ArrayList<>();
        treeNodeLinkList_12.add(treeNodeLink_121);
        treeNodeLinkList_12.add(treeNodeLink_122);

        treeNode_12.setTreeNodeLinkList(treeNodeLinkList_12);

        // 节点：111
        TreeNode treeNode_111 = new TreeNode();
        treeNode_111.setTreeId(10001L);
        treeNode_111.setTreeNodeId(111L);
        treeNode_111.setNodeType(2);
        treeNode_111.setNodeValue("果实A");

        // 节点：112
        TreeNode treeNode_112 = new TreeNode();
        treeNode_112.setTreeId(10001L);
        treeNode_112.setTreeNodeId(112L);
        treeNode_112.setNodeType(2);
        treeNode_112.setNodeValue("果实B");

        // 节点：121
        TreeNode treeNode_121 = new TreeNode();
        treeNode_121.setTreeId(10001L);
        treeNode_121.setTreeNodeId(121L);
        treeNode_121.setNodeType(2);
        treeNode_121.setNodeValue("果实C");

        // 节点：122
        TreeNode treeNode_122 = new TreeNode();
        treeNode_122.setTreeId(10001L);
        treeNode_122.setTreeNodeId(122L);
        treeNode_122.setNodeType(2);
        treeNode_122.setNodeValue("果实D");

        // 树根
        TreeRoot treeRoot = new TreeRoot();
        treeRoot.setTreeId(10001L);
        treeRoot.setTreeRootNodeId(1L);
        treeRoot.setTreeName("规则决策树");

        Map<Long, TreeNode> treeNodeMap = new HashMap<>();
        treeNodeMap.put(1L, treeNode_01);
        treeNodeMap.put(11L, treeNode_11);
        treeNodeMap.put(12L, treeNode_12);
        treeNodeMap.put(111L, treeNode_111);
        treeNodeMap.put(112L, treeNode_112);
        treeNodeMap.put(121L, treeNode_121);
        treeNodeMap.put(122L, treeNode_122);

        treeRich = new TreeRich(treeRoot, treeNodeMap);
    }

    @Test
    public void test_tree() {
        logger.info("决策树组合结构信息：\r\n" + JSON.toJSONString(treeRich));

        IEngine treeEngineHandle = new TreeEngineHandle();

        /**
         * 测试数据
         * 果实A：gender=man、age=22
         * 果实B：gender=man、age=29
         * 果实C：gender=woman、age=22
         * 果实D：gender=woman、age=29
         */
        Map<String, String> decisionMatter = new HashMap<>();
        decisionMatter.put("gender", "man");
        decisionMatter.put("age", "29");

        EngineResult result = treeEngineHandle.process(10001L, "Oli09pLkdjh", treeRich, decisionMatter);
        logger.info("测试结果：{}", JSON.toJSONString(result));

    }

}

小结

通过决策树的方式，虽然在前期的构建中需要耗费较多的时间与精力，但是在后期的业务增长以及代码维护中都会事半功倍。

代码以及图片来自于小傅哥

2theSunway
关注
Java面试复习大纲
系统看你学习很认真，随机送了一个月会员！
08-14 1265
集合、多线程、反射、注解和动态代理是Java开发中非常重要的基础技术。掌握这些技术可以帮助你更全面地理解Java的特性，更有效地进行软件开发。每个技术都有其独特的用法和最佳实践，建议通过项目实践加深理解。
Java知识点概览
qq_48403611的博客
08-03 4232
java后端开发常见面试题总结
决策树算法(Java实现)
01-24
决策树生成算法的Java实现，可能还有一些BUG，没有做仔细校验与测试，完成主要功能。决策树具体详解移步:http://blog.youkuaiyun.com/adiaixin123456/article/details/50573849 项目的目录结构分为四个文件夹algorithm，common，data，test (1)algorithm为算法，包括DecisionTree(决策树生成算法)、IAttrSelector(最佳分裂点属性选择算法接口)、BaseAttrSelector(基础的属性选择算法实现) (2)common为公用类，只包含了表示多叉树的类TreeNode (3)data为数据,包含了BaseRecord(基础记录，这里只有一个属性，就是要分类的属性Boolean的，其他数据库实体都应该继承该类) HummanAttrRecord(描述用户的属性类，包括收入、年龄、是否为学生、信用评级)、 EmAgeLevel(年龄枚举类)、EmCreditRate(信用枚举类)、EmIncome(收入枚举类)。 (4)test为测试类
一看就懂的决策树算法（java实现）
热门推荐
qq_38773180的博客
01-28 2万+
首先来看下本次案例创建得到的决策树长什么样 用于创建这棵决策树的数据如下（第一行的每一列为特征名称，最后一列为分类） 色泽,根蒂,敲声,纹理,脐部,触感,好瓜 青绿,蜷缩,浊响,清晰,凹陷,硬滑,好瓜 乌黑,蜷缩,沉闷,清晰,凹陷,硬滑,好瓜 乌黑,蜷缩,浊响,清晰,凹陷,硬滑,好瓜 青绿,蜷缩,沉闷,清晰,凹陷,硬滑,好瓜 浅白,蜷缩,浊响,清晰,凹陷,硬滑,好瓜 青绿,稍蜷,浊响,
决策树——Java代码之旅
四川兔兔的博客
05-08 1866
一、主类成员认识   我们概念讲解是在这里，下面便是成员变量。我们一点一点看，最后拉通走一遍。整个程序我是顺序运行的，给一个标题方便大家去找对应的方法 public class ID3 { /** * 数据集 */ Instances dataset; /** * 这个数据集是纯的（只有一个标签）？ */ boolean pure; /** * 决策类的数量. 二元分类它是2：0,1. */ int numClasses; /** * 可用实例。 其它实例不属
决策树算法（JAVA）
mengzhengyu1025的博客
07-04 837
决策树算法（JAVA）
基于java实现的决策树代码
11-14
功能： 1.读取文本数据建立决策树 2.可视化输出决策树 3.给定数据进行决策判断 4.计算决策命中率
Java多重判断
最新发布
03-19
在Java中，可以通过`if-else`和`switch-case`两种主要的方式来实现多重判断逻辑。 #### 使用 `if-else` 实现多重判断 当需要基于不同的条件执行不同代码块时，可以使用嵌套的`if-else`语句。这种方式适用于复杂的...
接口与抽象类识别技巧：JavaParser中精准判断类型的关键策略
![接口与抽象类识别技巧：JavaParser中精准判断类型的关键策略]...本文围绕JavaParser在抽象语法树（AST）层面的类型解析能力，系统研究了接口与抽象类的语法特征及其精准
2022年面试，整理全网初、中、高级常见 Java 面试题
q66562636的博客
07-01 2961
面试题答案见微信小程序 “Java 精选面试题”，3000 + 道面试题。内容持续更新中包含基础、集合、并发、JVM、Spring、Spring MVC、Spring Boot、Spring Cloud、Dubbo、MySQL、Redis、MyBaits、Zookeeper、Linux、数据结构与算法、项目管理工具、消息队列、设计模式、Nginx、常见 BUG 问题、网络编程等。————————————————面向对象编程有哪些特征？一、抽象和封装类和对象体现了抽象和封装抽象就是解释类与对象之间关系的词。类
Decision-Tree:java中决策树的简单实现
06-15
决策树 java中决策树的简单实现
决策树算法JAVA实现（包括C4.5和ID3）
04-17
决策树算法的java实现，包括C4.5和ID3的实现。
决策树Java代码实现
03-03
决策树Java代码实现
java实现的决策树算法
03-15
java实现的决策树算法，有注释，有实例
决策树java
12-19
决策树算法的java实现，试验数据来自data mining。
java决策树_归纳决策树ID3（Java实现）
weixin_30740019的博客
02-12 330
先上问题吧，我们统计了14天的气象数据(指标包括outlook，temperature，humidity，windy)，并已知这些天气是否打球(play)。如果给出新一天的气象指标数据:sunny,cool,high,TRUE，判断一下会不会去打球。table 1outlooktemperaturehumiditywindyplaysunnyhothighFALSEnosunnyhothighTR...
java决策树_java编写ID3决策树
weixin_42237925的博客
02-12 392
说明：每个样本都会装入Data样本对象，决策树生成算法接收的是一个Array样本列表，所以构建测试数据时也要符合格式，最后生成的决策树是树的根节点，通过里面提供的showTree()方法可查看整个树结构，下面奉上源码。Data.javapackage ai.tree.data;import java.util.HashMap;/*** 样本类* @author ChenLuyang* @date ...
java决策树框架_决策树算法(Java实现)
weixin_35554273的博客
03-02 777
【实例简介】决策树生成算法的Java实现，可能还有一些BUG，没有做仔细校验与测试，完成主要功能。决策树具体详解移步:http://blog.youkuaiyun.com/adiaixin123456/article/details/50573849项目的目录结构分为四个文件夹algorithm，common，data，test(1)algorithm为算法，包括DecisionTree(决策树生成算法)、I...
SparkMLlib Java 决策树分类算法(DecisionTree)
Spider_Black的博客
07-07 1622
我们在实际应用开发时，需整合各个模块的代码，使其粘合在一起，而Java就是最好的粘合工具，此篇文章中，介绍了SparkMLlib的决策树，使用java开发做分类。
C语言编程：深入理解if-else语句
C语言中的if-else语句是条件判断的关键工具，用于根据不同的条件执行不同的代码块。在C语言中，if和else关键字是编写选择结构的重要组成部分。 **if-else语句详解** if-else语句允许程序在某个条件满足时执行一部分...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值