Java 流程控制 顺序 分支

Java 分支控制

在程序中，程序运行的流程控制决定程序是如何运行的。

主要是一下三大流程控制语句

  • 顺序控制
  • 分支控制
  • 循环控制

顺序控制

顺序控制：指程序从上到下顺序执行，中间没有任何判断与跳转。

以下例子就是顺序控制

public class ProcessControl {
    public static void main (String[] args) {
        int num1 = 123;
        int num2 = 456;
        int reslut = num1 + num2;
    }
}

从上到下每条语句依次执行：

  1. 定义num1变量并赋值 123
  2. 定义 num2变量并赋值 456
  3. 定义变量 result 并将 num1 加 num2 的和赋给 result

这就是以上代码的执行顺序

分支控制

分支控制：让程序有选择的执行，Java分支控制分为四种

  • 单分支
  • 双分支
  • 多分支
  • Switch 分支

单分支

基本语法：

/*
if (判断条件) {
    满足条件后需要执行的语句;
    可以有多条语句;
    但是每条语句结束后需要加上;  // ; 
}
*/

// 实际应用代码
public class ProcessControl {
    public static void main (String[] args) {
        // 这里作为控制开关
        boolean control = true;
       	
        // 如果 control 为 true 就执行 if 里面的语句，如果为 false 直接跳过改代码快执行后面的语句
        // 这里的 control 也可以换成其他条件表达式，如 2 > 3 等等，只要表达式最后的返回值是 boolean 类型就可以
        if (control) {
            System.out.println("执行了第一条语句");
            System.out.println("执行了第二条语句");
            System.out.println("执行了第三条语句");
            System.out.println("执行了第四条语句");
            System.out.println("执行了最后一句");
        }
        
        System.out.println("执行了外面的语句");
    }
}

运行上面代码，并尝试把 contorl 改为 false 看看和 true 的区别

// 如果满足条件后需要执行的语句只有一条也可以这样写
if (2 < 3) System.out.println("条件满足了");  // 虽然可以这样写但还是建议加上 {} 增强代码阅读性

实际应用：

/* 目标 让用户输入年龄
   然后判断年龄，
   如果小于 18 岁，打印 未成年人请在家长陪同下观看  然后再播放
   如果大于 18 岁，直接播放
*/

// 先导入扫描器 Scanner
import java.util.Scanner;

public class AgeJudge {
    public static void main (String[] args) {
        // 创建扫描器对象
        Scanner input = new Scanner(System.in);
        // 提示用户输入
        System.out.print("请输入你的年龄：");  // print 不换行  println换行
        // 创建变量接收用户输入的信息
        byte age = input.nextByte();
        
        // 判断年龄
        if (age < 18) {
            System.out.println("未成年人请在家长陪同下观看");
        }
        
        // 执行播放
        System.out.println("播放......");
    }
}

双分支

双方在就是在单分支的基础上，增加了一条对条件表达式为false时候的处理分支

基本语法：

if (条件表达式) {
    // 如果条件表达式为 true执行这个大括号里的代码
    需要执行的语句;
}
else {
    // 如果条件表达式为 false 执行这个大括号里的代码
    需要执行的语句;
}

实际应用：

/* 目标 让用户输入年龄
   然后判断年龄，
   如果小于 18 岁，打印你还年轻 再继续执行后面的程序
   如果大于 18 岁，打印你个糟老头子 再继续执行后面的程序
*/

// 先导入扫描器 Scanner
import java.util.Scanner;

public class AgeJudge {
    public static void main (String[] args) {
        // 创建扫描器对象
        Scanner input = new Scanner(System.in);
        // 提示用户输入
        System.out.print("请输入你的年龄：");  // print 不换行  println换行
        // 创建变量接收用户输入的信息
        byte age = input.nextByte();
        
        // 判断年龄
        if (age < 18) {
            System.out.println("你还年轻");
        }
        else {
            System.out.println("你个糟老头子");
        }
        // 继续执行后面的代码
        System.out.println("我是后面的代码");
    }
}

多分支

多分支就是在双分支的中间再插入一个判断条件

// 基本语法
if (条件表达式1) {满足该条件后要运行的代码;}  // 如果语句较短{}可以不换行 

else if (条件表达式2) {
    满足该条件后要运行的代码;  // 建议使用行尾风格
}

else 既不满足条件1，也不满足条件2 的时候要运行的代码;  // {} 可以省略，但不建议

实际应用：

/*
	目标：
	让用户输入年龄
	如果 低于 18 岁 输出 你还未成年 再运行后面的代码
	如果 等于 18 岁 输出 你已成年   在运行后面的代码
	如果 大于 18 岁 输出 你是该糟老头子 再运行后面的代码
*/

// 先导入扫描器 Scanner
import java.util.Scanner;

public class AgeJudge {
    public static void main (String[] args) {
        // 创建扫描器对象
        Scanner input = new Scanner(System.in);
        // 提示用户输入
        System.out.print("请输入你的年龄：");  // print 不换行  println换行
        // 创建变量接收用户输入的信息
        byte age = input.nextByte();
        
        // 判断年龄
        if (age < 18) {
            System.out.println("你还未成年");
        }
        else if (age == 18) {
            System.out.println("你已成年");
        }
        else {
            System.out.println("你是个糟老头子");
        }
        // 继续执行后面的代码
        System.out.println("我是后面的代码");
    }
}

注意：

分支控制

  1. 必须有 if (条件判断) {......}
  2. else if (判断条件) {......} 能拥有无数个
  3. 一个 if 代码块只能拥有0 或 1 个 else {......} 如果加了else 只能放该if 代码块的最后

综合应用

将前面学习到的内容综合应用起来

编写一个简单的收银台

需求：

苹果 价格5元/个

桃子 价格6元/个

梨 价格4元/个

西瓜 价格8元/个

总余额 100 元

求 先打印出总余额 即 商品价格列表

要求用户输入 商品编号

输入购买数量

自动扣除余额并打印购买信息

// 导入Scanner
import java.util.Scanner;

public class Checkout {
    public static void main (String[] args) {
        // 余额
        double balance = 100;
        // 商品价格
        int apple_price = 5;
        int peach_price = 6;
        int pear_price = 4;
        int watermelon_price = 8;
        // 先打印余额及价格信息
        System.out.println("欢迎光临，您的余额为：" + balance + "元");
        System.out.println("===================================");  // 分割线
        // 打印价格标头
        System.out.println("编号\t商品\t价格");
        // 打印商品价格
        System.out.println("1\t" + "苹果\t" + apple_price);
        System.out.println("2\t" + "桃\t" + peach_price);
        System.out.println("3\t" + "梨\t" + pear_price);
        System.out.println("4\t" + "西瓜\t" + watermelon_price);
        
        // 创建 Scanner 对象
        Scanner input = new Scanner(System.in);
        
        // 提示用户输入商品编号
        System.out.print("请输入您要购买的商品编号：");
        // 记录用户输入的商品编号
        int product_num = input.nextInt();
        
        // 先判断用户输入的商品编号是否存在
        if (product_num > 0 && product_num <= 4) { // 如果存在执行该代码块的代码
            
            // 提示用户输入购买数量
        	System.out.print("请输入您要购买的数量：");
        	// 记录用户购买数量
        	int buy_count = input.nextInt();
            
            // 用户选择苹果
            if (product_num == 1) {
                
                // 先计算总花费
                double total_cost = buy_count * apple_price;
                
                // 先判断余额是否足够支付，如果不够打印取消交易
                if (total_cost <= balance) {
                    System.out.println("您买苹果共花费了 " + total_cost + "余额还剩 " + 
                                       (balance - total_cost) + "元\n交易完成");
                }
                
                else System.out.println("余额不足，取消交易");
            }
            
            // 用户选择桃子
            else if (product_num == 2) {
                
                // 先计算总花费
                double total_cost = buy_count * peach_price;
                
                // 先判断余额是否足够支付，如果不够打印取消交易
                if (total_cost <= balance) {
                    System.out.println("您买桃子共花费了 " + total_cost + "余额还剩 " + 
                                       (balance - total_cost) + "元\n交易完成");
                }                
                else System.out.println("余额不足，取消交易");
            }
            
            // 用户选择梨
            else if (product_num == 3) {
                
                // 先计算总花费
                double total_cost = buy_count * pear_price;
                
                // 先判断余额是否足够支付，如果不够打印取消交易
                if (total_cost <= balance) {
                    System.out.println("您买梨共花费了 " + total_cost + "余额还剩 " + 
                                       (balance - total_cost) + "元\n交易完成");
                }                
                else System.out.println("余额不足，取消交易");
            }
            
            // 用户选择西瓜
            else if (product_num == 4) {
                
                // 先计算总花费
                double total_cost = buy_count * watermelon_price;
                // 先判断余额是否足够支付，如果不够打印取消交易
                
                if (total_cost <= balance) {
                    System.out.println("您买西瓜共花费了 " + total_cost + "余额还剩 " + 
                                       (balance - total_cost) + "元\n交易完成");
                }                
                else System.out.println("余额不足，取消交易");
            }
            
        }
        else{
            System.out.println("您输入的商品编号有误，请重新尝试");
        }
        
    }
}

以上案例用到了我们前面学习的 变量、转义字符、字符串拼接、Scanner、分支控制、分支嵌套、逻辑运算符、算术运算符，将我们目前学到的东西套用起来能得到这么一个简陋的收银台。

Switch 分支

基本语法：

switch (值){
    case 常量1:
        需要执行的语句1;
        break;  // 结束 switch 分支
    case 常量2:
        需要执行的语句2;
        break;
    default:
        如果上面的常量都不能与值匹配要执行的代码块;
}

语法说明：

  1. switch 需要有一个 值 可以是表达式、变量等，但最终的返回值只能是 byte、short、char、int、enum、String
  2. case 后面带的常量如果与值匹配则执行这个case 里的代码块（一个switch 里能有多个 case）
  3. case 后面只能接受 常量值（可以是计算后的常量值，也可以是一个常量值），不能接受变量。
  4. case 只能接受byte、short、int、char、enum、String 这六种类型的常量值。可以同时接受以上六种不同类型的常量值，但不同类型之间必须是能够满足自动转换的类型 （如： byte => int 或者 int => char等）。
  5. break是退出switch分支，如果一个case的常量与常量匹配，执行完这个case里的语句后，如果有break则直接退出switch分支，如果没有break则会直接执行这个 case 下面 case 常量n 的所有代码，直到执行到 break 才会退出 switch分支，如果途中没有 break 则会一直往下执行完switch分支，这种现象叫 穿透。
  6. default 会在所有的 case 常量都无法与值匹配的时候执行，如果有出现穿透效果也会执行 default 里的语句。（default 是可选的）

Switch 和 if 的比较及使用选择

  1. 如果判断的具体数值不多，且符合 byte、short、int、char、enum、String 这六种类型。虽然两个都可以使用，但是建议使用 switch语句，因为代码可读性前，且后期维护修改会比 if 语句方便。
  2. 其他情况：对区间判断，对结果类型为 boolean，使用 if ，if 的使用范围更广。
posted @   假文艺青年。  阅读(64)  评论(0)  编辑  收藏  举报
相关博文：
· Java 跳转控制
· Java 循环 for while do {...} while (...)
· 控制语句（分支结构）
· java控制流程
· Java 流程控制
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 开源Multi-agent AI智能体框架aevatar.ai，欢迎大家贡献代码
· Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
点击右上角即可分享
微信分享提示
AI IDE Trae