2023_10_15_DAY_01_JAVA_SE_Java基础知识_下_流程控制语句

分支【选择】结构

if语句

if (表达式) {
	执行语句块;
}
//if语句的代码执行过程为：如果条件表达式返回真值，则执行功能代码块中的语句；
//如果条件表达式返回值为假，则不执行功能代码块。

语法说明：

1. if是该语句中的关键字，后续小括号不可省略；
2. 条件表达式返回的结果为布尔型，当返回为真值时才能执行if功能代码；
3. 功能代码块为多行时，应将其放在花括号"{}"中间，当功能代码块为单行时，则不需要花括号；
4. 不论if语句块是单行还是多行，建议都用花括号"{}"括起来；
5. if()子句后不能跟分号";"

if语句(二选一)

在程序的执行过程中，if语句只执行条件表达式返回值为真时的操作。但如果需要返回值为真或假时都执行各自相应操作，就可以使用if-else语句来完成。if-else语句语法如下：

if(条件表达式){
    功能代码块1
}else{
    功能代码块2
}

if-else语句的代码执行过程为：当条件表达式返回值为真时，执行功能代码块1，当条件表达式返回值为假时，执行else后面的功能代码2。与if语句法格式相同，如果功能代码1和2只有一句，则不需要加花括号"{}"。
语法说明：

1. if-else语句的代码执行过程等价于 三目条件运算符，变量 = 布尔表达式 ? 语句1:语句2
2. 如果布尔表达式的值为true，则执行语句1；如果布尔表达式的值为false，则执行语句2

if语句(多选一)

当条件为多个时，Java提供了专门的多分支if- else if -else语句以实现条件的多重选择，多分支语句的语法如下：

if(条件表达式1){
    功能代码块1;
}else if(条件表达式2){
    功能代码块2;
}else if(条件表达式3){
    功能代码块3;
    ... ...
}else{
    功能代码块n;
}

语法说明：

1. else if是else和if两个关键字，中间使用空格进行间隔；
2. 条件表达式返回值都是布尔类型；
3. else if语句可以有任意多句；
4. 最后的else语句为可选；
5. 如果功能代码部分只有一条语句而不是语句块，花括号"{}"可以省略。

if-else if-else语句的代码执行过程为：
1.当条件表达式1返回值为真时，则执行功能代码块1；
2.当条件表达式1返回值为假时且条件表达式2返回值为真时，则执行功能代码块2；
3.如果条件表达式1、条件表达式2都返回假且条件表达式3返回值为真，则执行功能代码块3，
4.依次类推，如果所有条件都不成立，则执行else语句的功能代码。

eg:
使用if-else if-else语句实现百分制成绩到成绩等级的转换。

public class If_Sample3{
    public static void main(String args[]) {
        int i = 55;
        if (i <= 100 && i >= 90) {
            System.out.println("成绩是A");
        } else if (i >= 80) {
            System.out.println("成绩是B");
        } else if (i >= 70) {
            System.out.println("成绩是C");
        } else if (i >= 60) {
            System.out.println("成绩是D");
        } else {
            System.out.println("成绩是E");
        }
    }
}

switch语句

switch语句从多种情况中选择一种执行，在结构上比if语句要清晰很多。switch语句的语法格式如下:

switch(表达式){
   case 取值1:
        语句块1;
        [break;]
   case 取值2:
        语句块2;
        [break;]
   ......
   case 取值n:
        语句块n;
        [break;]
   default:
        语句块n+1;
   }

语法说明：

1. 表达式的类型只能为byte、short、char、int，在JDK7中增加了对String类型的支持；
2. case语句是标号语句，只确定程序的入口；
3. 值1、值2......值n只能为常数或常量，不能为变量，而且值不能重复；
4. 功能代码部分可以写任意多句；
5. break关键字结束switch语句，为可选项；
6. default语句功能类似于if-else语句中的else。
   eg: 使用switch语句实现百分制成绩到成绩等级的转换。

public class Switch_sample2 {
    public static void main(String[] args) {
        int score = 100;
        switch (score / 10) {
            case 10:
            case 9:
                System.out.println("成绩等级为A");
                break;
            case 8:
                System.out.println("成绩等级为B");
                break;
            case 7:
                System.out.println("成绩等级为C");
                break;
            case 6:
                System.out.println("成绩等级为D");
                break;
            default:
                System.out.println("成绩等级为E");
        }
    }
}

循环结构

循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。需要被反复执行的这段代码称为循环体，它由循环结构中的循环条件决定是继续执行循环体还是终止循环。根据判断条件,循环结构又可细分为以下两种形式:

1. 先判断后执行的循环结构
2. 先执行后判断的循环结构。

while语句 (当型循环-先判断后执行)

while(循环条件){
    循环体;
}

while语句的代码执行过程为：
首先判断循环条件，如果循环条件为true，则执行循环体代码，然后再判断循环条件，直到循环条件不成立时停止执行。如果首先判断循环条件就为false，则不执行循环体，直接执行while语句后续的代码。
语法说明：

1. 循环条件的类型为布尔类型，指循环成立的条件；
2. 花括号{}不是必须的，当循环体中只有一条语句时，可以省略；
3. 循环体是需要重复执行的代码。

do-while语句 (直到型循环-先执行后判断)

do{
    循环体;
}while(循环条件);

语法说明：

1. 循环体是重复执行的代码部分，循环条件要求是布尔类型，值为true时执行循环体，否则循环结束，最后整个语句以分号结束；
2. do-while语句是 "先循环再判断"的流程控制结构。

for语句 (当型循环-先判断后执行)

for(表达式1;表达式2;表达式3){
	循环体;
}

语法说明：

1. 表达式1用于初始化，一般书写变量初始化的代码，例如循环变量的声明、赋值等，它在for语句中执行且只执行一次。表达式1可以为空；
2. 表达式2是循环条件，要求必须为布尔类型，如果该条件为空，则默认为true，即条件成立；
3. 表达式3为迭代语句，是指循环变量变化的语句，一般书写i++、i--这样的结构。该语句可以为空。
4. 循环体指循环重复执行的功能代码。
5. 花括号{}不是必须的，当循环体部分只有一条语句时可以省略。

eg:用for循环改写从1到100的所有奇数相加的和。

public class For_OddSum {
    public static void main(String args[]) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 != 0)
            	sum += i;
        }
        System.out.println("1到100之间的奇数和为" + sum);
    }
}

死循环

循环语句中如果循环条件永远为真，那么这样的循环就是死循环。死循环的破坏力极强，导致软件的其它功能无法执行，而且只能通过杀死线程、结束进程等方法被动解除，所以一般情况下都要在代码中避免死循环的出现。
在某些特定场景，比如温控系统、十字路口的车牌识别系统，使用特定的技术后死循环还是可以存在的，并且发发挥着重要作用。

嵌套循环

嵌套循环，程序中常用的一种方法，如果在一个循环语句A中又包含另一个循环语句B，那么语句A就是嵌套循环语句，这种结构称为循环嵌套。内嵌的循环B中还可以嵌套循环C，这就是多层循环。语句A也称为主循环或者外循环，B称为内循环。各种语言中关于循环的嵌套的概念都是一样的。
eg:

public class Multiplication_Sample {
    public static void main(String args[]) {
        for (int i = 1; i<=3; i++) {
            System.out.println("***");
        }
    }
}

循环的中断

在使用循环语句时，只有循环条件表达式的值为false时，才能结束循环。有时，想提前中断循环，要实现这一点，只需要在循环语句块中添加break或continue语句。

break语句

在前面switch语句的介绍中已经接触过break语句，其功能是中断switch语句的执行。同样，break语句可以出现在while、do...while、for循环等语句中，能够立即结束本循环语句的执行。
eg:
请计算一个最小整数N，使得1+2+3...+N的和大于666首次成立。

public class Break_Sample1 {
  public static void main(String[] args) {
      int i, sum=0;
      for (i = 1; i < 101; i++) {
          sum += i;
          if (sum >= 666) {
              break;
          }
      }
      System.out.println("从1到" + i + "的和为" + sum);
  }
}

Continue语句

continue语句只能出现在循环结构中，也完成循环的终止。但与break语句的区别在于：continue语句只跳出一次循环，整个语句还继续执行；break语句则完全跳出它所在或所标记的循环。下面以while语句为例，来说明continue语句的功能:
例 显示20以内的奇数。

public class Continue_Sample1 {
    public static void main(String[] args) {
        for (int i = 1; i < 20; i++) {
            if ((i % 2) == 0) {
                continue;
            }
            System.out.print(i + " ");
        }
    }
}

continue label语句可以出现在任何语句体中，其作用是结束指定循环语句的当前循环次的执行。【了解】
eg:

public class Continue_Sample3 {
    public static void main(String[] args) {
        label1: for (int i = 0; i < 10; i++) {
            System.out.print("\n");
            for (int j = 0; j < 10; j++) {
                System.out.print(j + " ");
                if (j == 5) {
                    continue label1;
                }
            }
        }
    }
}

控制语句的应用

水仙花数

问题描述：水仙花数指一个特殊的三位数，它的各位数字的立方和与其自身相等。请输出所有的水仙花数。
编程思路：关键是将三位数的个位、十位和百位数字分别拆分出来。
eg:

public class Narcissus {
    public static void main(String args[]) {
        for (int i = 100; i < 1000; i++) { // 循环所有三位数
            int a = i % 10; // 拆分出个位数字
            int b = (i / 10) % 10; // 拆分出十位数字
            int c = i / 100; // 拆分出百位数字
            // 判断立方和是否等于自身
            if (a * a * a + b * b * b + c * c * c == i) {
                System.out.println(i);
            }
        }
    }
}
在该段代码中，要掌握拆分个位数字、十位数字和百位数字的方法。

求两个自然数的最大公约数

问题描述：最大公约数指两个数字公共的约数中最大的，例如数字3的约数有1、3，数字9的约数有1、3、9，则数字3和数字9的公共约数有1和3，其中3是最大的公约数。
第一种编程思路：假设初始值从1开始逐步增1，每次把能同时使两个数整除的值都存储起来，那么最后一个存储起来的值就是最大的约数。
eg:例求8和12的最大公约数。

public class CommonDivisor1 {
    public static void main(String[] args) {
        int m = 8;
        int n = 12;
        int result = 1;
        for (int i = 1; i <= m; i++) {
            if ((m % i == 0) && (n % i == 0)) {
                result = i;
            }
        }
        System.out.println(result);
    }
}

第二种编程思路：设定初始值为两个数字中最小的数字，逐步减1，那么第一次得到的能同时使两个数整除的值就是最大公约数。
eg:例 求9和12的最大公约数。

public class CommonDivisor2 {
    public static void main(String[] args) {
        int n = 9;
        int m = 12;
        int result = n > m ? m : n;
        for (int i = result; i >= 1; i--) {
            if ((n % i == 0) && (m % i == 0)) {
                result = i;
                break; // 结束循环
            }
        }
        System.out.println(result);
    }
}

百元百鸡问题

问题描述：母鸡3元/只，公鸡4元/只，小鸡0.5元/只，如果花100元钱买100只鸡，每一种鸡可以买0只，请问有哪些可能？
百元百鸡问题属于数学上的组合问题，可以通过循环控制语句来列举所有的情况，并判断其是否符合要求。
第一种编程思路：首先确定母鸡的购买数量为0，使公鸡的购买数量从0-100逐次变化，每当公鸡的数量变化一次，小鸡的数量就从0逐次变化到100，其数值组合如表所示。
例 用第一种思路解决百元百鸡问题

public class ChickenPurchase1 {
    public static void main(String[] args) {
        for (int i = 0; i <= 100; i++) { // 母鸡数量
            for (int j = 0; j <= 100; j++) { // 公鸡数量
                for (int k = 0; k <= 100; k++) { // 小鸡数量
                    // 判断数量是否为100，以及金额是否为100
                    if ((i+j+k == 100) && (i*3+j*4+k*0.5 == 100)) {
                        System.out.println("母鸡数量：" + i+ "公鸡数量：" + j + "小鸡数量" + k);
                    }
                }
            }
        }
    }
}

我们简单地使用第二种编程思路优化一下程序结构。
第二种编程思路：100元最多能购买33只母鸡，若只买公鸡只能买25只，而按照用100元买100只的要求，100减去公鸡和母鸡的购买数量即是小鸡的购买数量。

public class ChickenPurchase2 {
    public static void main(String[] args) {
        for (int i = 0; i <= 33; i++) { // 母鸡的购买数量
            for (int j = 0; j <= 25; j++) { // 公鸡的购买数量
                int k = 100 - i - j; // 小鸡的购买数量
                // 判断购买金额是否为100
                if (i*3+j*4+k*0.5 == 100) {
                    System.out.println("母鸡的购买数量：" + i+ "公鸡的购买数量：" + j + "小鸡的购买数量" + k);
                }
            }
        }
    }
}

打印图形

编程思路：在外部使用循环语句执行5次每次打印1行，每行的内容分别为空格和星号""，每行空格缩进的数量为5减去所在行数，星号""的数量是所在行数的2倍减1。在内部使用循环语句首先打印空格，然后打印星号"*"，对应的打印次数用循环次数控制，打印星号之后就可以换行。
例 星型图形的打印。

public class StarPrint {
    public static void main(String[] args) {
        for (int row = 1; row <= 5; row++) { // 外层循环执行换行
            // 打印空格的数量为5减去所在行数
            for (int c1 = 0; c1 < 5 - row; c1++) {
                System.out.print(' ');
            }
            // 打印星号的数量为所在行数的2倍减1
            for (int c2 = 0; c2 < 2 * row - 1; c2++) {
                System.out.print('*');
            }
            // 换行
            System.out.println();
        }
    }
}

质数判断

问题描述：如何判断某个自然数是否为质数。
质数是只能被1和自身整除的自然数，也称素数，质数中最小的为2。所有自然数都可以被自身和1整除。
编程思路：我们只需判断一个数能否被1和自身以外的数字整除即可，大于其本身的自然数除外。若数字为n，则只需判断从2到n-1之间的所有数字，即程序只需判断该数能否被区间[2,n-1]内的某个自然数整除即可，若在区间内存在能被整除的数则说明不是质数。

public class Exponent {
    public static void main(String[] args) {
        int n = 29;
        boolean b = true; //布尔类型，表示是否为质数，初始值为真
        for (int i = 2; i < n; i++) {
            //若能够整除则不是质数
            if (n % i == 0) {
                b = false;
                break; //跳出循环
            }
        }
        //输出结果，判断是否为质数
        if (b) {
            System.out.println(n + "是质数");
        } else {
            System.out.println(n + "不是质数");
        }
    }
}

本栏目推荐文章
• 【Shell基础】Bash基础与Linux三剑客
• 跟着阿灵学前端(1)——HTML 基础
• 跟着阿灵学前端(2)——CSS 基础
• OSPF理论基础
• （坚持每天写算法）基础算法复习与学习part1基础算法1-7——高精度减法（处理t=1和t>1代码的写法，t为操作次数）
• 9-函数基础
• 4- if 流程语句和案例
• 春眠不觉晓，Java数据类型知多少？基础牢不牢看完本文就有数了
• Servlet基础开发
• Linux基础命令 [补档-2023-06-28]

JAVA_SE_Java 语句 基础知识 流程 基础java_se_java语句 基础知识 流程 运算符 变量java_se_java基础知识 java_se_java基础知识 基础 知识 语句 架构 流程 基础 语句 基础知识 基础 知识 语句 基础python 语言基础 语句 语言 基础 语句 基础 笔记python 语句 基础python 9.0 流程 基础git