200-Java语言基础-Java编程入门-004 | Java分支与循环

一、流程控制语句

可以控制程序的执行流程

在程序开发的过程之中一共会存在有三种程序逻辑：顺序结构、条件分支（选择）结构、循环结构。

顺序结构的定义，即：所有的程序将按照定义的代码从上往下、顺序依次执行。

二、条件分支（选择）结构

    对于条件分支（选择）语句主要有两类使用形式，if语句、switch语句

• IF分支结构语句

    if分支结构主要是针对于关系表达式进行判断处理的分支操作。

    if语句格式1

 1 // if语句格式1
 2 if (比较表达式) {
 3     语句体;
 4 }
 5
 6 public class JavaDemo {
 7   public static void main(String[] args) {
 8     /*
 9      * D:执行流程：
10            * 先计算比较表达式的值，看其返回值是true还是false。
11            * 如果是true，就执行语句体；
12            * 如果是false，就不执行语句体；
13      */
14     int age = 19;
15     if (age >= 18) {
16       System.out.println("可以浏览本网站");
17     }
18     System.out.println("sorry");
19   }
20 }
21     /*
22      * if语句注意事项
23      * a:比较表达式无论简单还是复杂，结果必须是boolean类型
24      * b:if语句控制的语句体如果是一条语句，大括号可以省略；
25      * 如果是多条语句，就不能省略。建议永远不要省略。
26      * c:一般来说：有左大括号就没有分号，有分号就没有左大括号
27      */

    if语句格式2

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4     *  A:if语句的格式2
 5     *
 6       if(比较表达式) {
 7          语句体1;
 8       }else {
 9          语句体2;
10       }
11     * B:执行流程：
12       * 首先计算比较表达式的值，看其返回值是true还是false。
13       * 如果是true，就执行语句体1；
14       * 如果是false，就执行语句体2；
15     * C:案例演示
16       * a:获取两个数据中较大的值
17       * b:判断一个数据是奇数还是偶数,并输出是奇数还是偶数
18
19       * 注意事项：else后面是没有比较表达式的，只有if后面有。
20      */
21
22     int x = 1;
23     if (x == 1) {
24       System.out.println("北京欢迎您");
25     } else {
26       System.out.println("哪来回哪儿去");
27     }
28     // 获取两个数据中较大的值
29     int a = 20;
30     int b = 13;
31     int max;
32     if (a > b) {
33       max = a;
34     } else {
35       max = b;
36     }
37     System.out.println("max = " + max);
38
39     // 判断一个数据是奇数还是偶数,并输出是奇数还是偶数
40     int num = 666;
41     if (num % 2 == 0) {
42       System.out.println(num + "是一个偶数");
43     } else {
44       System.out.println(num + "是一个奇数");
45     }
46   }
47 }

    if语句的格式2和三元的相互转换问题

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4     * A:案例演示
 5     * if语句和三元运算符完成同一个效果
 6     * B:案例演示
 7     * if语句和三元运算符的区别
 8
 9     * 三元运算符实现的，都可以采用if语句实现。反之不成立。
10
11     * 什么时候if语句实现不能用三元改进呢?
12     * 当if语句控制的操作是一个输出语句的时候就不能。
13     * 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。
14      */
15
16     // 获取两个数据中较大的值
17     int a = 20;
18     int b = 13;
19     int max;
20     if (a > b) {
21       max = a;
22     } else {
23       max = b;
24     }
25     System.out.println("max = " + max);
26
27     int x = 111;
28     int y = 557;
29     int max1 = (x > y) ? x : y;
30     System.out.println("max = " + max1);
31   }
32 }

    if语句格式3

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4     * A:if语句的格式3：
 5     *
 6         if(比较表达式1) {
 7            语句体1;
 8         }else if(比较表达式2) {
 9            语句体2;
10         }else if(比较表达式3) {
11            语句体3;
12         }
13         ...
14         else {
15            语句体n+1;
16         }
17     * B:执行流程：
18       * 首先计算比较表达式1看其返回值是true还是false，
19       * 如果是true，就执行语句体1，if语句结束。
20       * 如果是false，接着计算比较表达式2看其返回值是true还是false，
21
22       * 如果是true，就执行语句体2，if语句结束。
23       * 如果是false，接着计算比较表达式3看其返回值是true还是false，
24
25       * 如果都是false，就执行语句体n+1。
26     * C:注意事项:最后一个else可以省略,但是建议不要省略,可以对范围外的错误值提示
27      */
28     int x = 1;
29     if (x == 1) {
30       System.out.println("北京欢迎您");
31     } else if (x == 0) {
32       System.out.println("上海欢迎您");
33     } else {
34       System.out.println("无法识别");
35     }
36   }
37 }

• switch分支语句

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4     * A:switch语句的格式
 5     *
 6     switch(表达式) {   // 基本数据类型可以接收byte、short、char、int
 7         case 值1：     // 引用数据类型可以接收枚举（JDK1.5）、String字符串（JDK1.7）
 8             语句体1;
 9             break;
10         case 值2：
11             语句体2;
12             break;
13           …
14         default：
15             语句体n+1;
16             break;
17       }
18     * B:switch语句的格式解释
19     * C:面试题
20       * byte可以作为switch的表达式吗?可以
21       * long可以作为switch的表达式吗?不可以
22       * String可以作为switch的表达式吗?可以
23     * C:执行流程
24       * 先计算表达式的值
25       * 然后和case后面的匹配，如果有就执行对应的语句，否则执行default控制的语句
26      */
27     String name = "张三";
28     String gender = "男性";
29     switch (gender) {
30     case "男性":
31       System.out.println(name + "是一位" + gender + "喜欢吃饭睡觉码代码");
32       break;
33     case "女性":
34       System.out.println(name + "是一位" + gender + "喜欢逛街购物美容");
35       break;
36     default:
37       System.out.println(name + "是一位" + gender + "啥也不是");
38       break;
39     }
40   }
41 }

    选择结构switch语句的注意事项：

• case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的
• default可以省略吗?
• 可以省略，但是不建议，因为它的作用是对不正确的情况给出提示。
• break可以省略吗?
• 最后一个可以省略,其他最好不要省略
• 会出现一个现象：case穿透。
• 最终我们建议不要省略
• default一定要在最后吗?
• 不是，可以在任意位置。但是建议在最后。
• switch语句的结束条件
• 遇到break就结束了
• 执行到switch的右大括号就结束了

 

三、选择结构if语句和switch语句的区别

    总结switch语句和if语句的各自使用场景：

• switch建议判断固定值的时候用
• if建议判断区间或范围的时候用

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * 一年有四季
 5      */
 6     Scanner sc =  new Scanner(System.in);
 7     System.out.println("请输入正确的月份");
 8     int month = sc.nextInt();
 9     switch (month) {
10     case 3:
11     case 4:
12     case 5:
13       System.out.println("春季");
14       break;
15     case 6:
16     case 7:
17     case 8:
18       System.out.println("夏季");
19       break;
20     case 9:
21     case 10:
22     case 11:
23       System.out.println("秋季");
24       break;
25     case 12:
26     case 1:
27     case 2:
28       System.out.println("冬季");
29       break;
30     default:
31       System.out.println("输入错误");
32       break;
33     }
34
35     // 用if语句来完成
36     if (month >= 1 && month <= 12) {
37       if (month >= 3 && month <= 5) {
38         System.out.println("春季");
39       } else if (month >= 6 && month <= 8) {
40         System.out.println("夏季");
41       } else if (month >= 9 && month <= 10) {
42         System.out.println("秋季");
43       } else {
44         System.out.println("冬季");
45       }
46     } else {
47       System.out.println("输入错误");
48     }
49
50   }
51 }

三、循环结构语句

• for循环结构

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * 循环结构for语句的格式：
 5      *
 6     for(初始化表达式; 条件表达式; 循环后的操作表达式) {
 7            循环体;
 8     }
 9      * C执行流程：
10        * a:执行初始化语句
11        * b:执行判断条件语句,看其返回值是true还是false
12            * 如果是true，就继续执行
13            * 如果是false，就结束循环
14        * c:执行循环体语句;
15        * d:执行循环后的操作表达式
16        * e:回到B继续。
17      * D:案例演示
18        * 在控制台输出10次"helloworld"
19      */
20     for (int i = 0; i < 11; i++) {
21       System.out.println("Hello World!");
22     }
23   }
24 }
25
26 public class JavaDemo {
27   public static void main(String[] args) {
28     /*
29      * A:案例演示
30        * 需求：请在控制台输出数据1-10
31        * 需求：请在控制台输出数据10-1
32      * B:注意事项
33        * a:判断条件语句无论简单还是复杂结果是boolean类型。
34        * b:循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略。
35        * c:一般来说：有左大括号就没有分号，有分号就没有左大括号
36      */
37
38     // 请在控制台输出数据1-10
39     for (int i = 1; i < 11; i++) {
40       System.out.println("i = " + i);
41     }
42     System.out.println("---------------");
43     // 请在控制台输出数据10-1
44     for (int i = 10; i > 0; i--) {
45       System.out.println("i = " + i);
46     }
47   }
48 }

    循环结构for语句的练习之求和思想

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:案例演示
 5        * 需求：求出1-10之间数据之和
 6      * B:学生练习
 7        * 需求：求出1-100之间偶数和
 8        * 需求：求出1-100之间奇数和
 9      */
10
11     // 求出1-10之间数据之和
12     int sum = 0;
13     for (int i = 1; i < 11; i++) {
14       sum += i;
15     }
16     System.out.println("sum = " + sum);
17     System.out.println("---------------");
18     int sum1 = 0;
19     int sum2 = 0;
20     // 求出1-100之间偶数和
21     // 求出1-100之间奇数和
22     for (int i = 1; i < 101; i++) {
23       if (i % 2 == 0) {
24         sum1 += i;
25       } else {
26         sum2 += i;
27       }
28     }
29     System.out.println("奇数和 = " + sum1);
30     System.out.println("偶数和 = " + sum2);
31   }
32 }

    循环结构for语句的练习之水仙花

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:案例演示
 5        * 需求：在控制台输出所有的”水仙花数”
 6        * 所谓的水仙花数是指一个三位数，其各位数字的立方和等于该数本身。
 7        * 举例：153就是一个水仙花数。
 8        * 153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153
 9        * 分析：
10        *  100 ~ 999
11        *  获取每一个位数的值、百位、十位、个位
12        *  判断各位数的立方和等于该数本身
13      */
14     int num = 0;
15     for (int i = 100; i < 1000; i++) {       // 获取100 ~ 999 的数\
16       int ge = i % 10;                       // 123 %(模、取余) 10 = 3
17       int shi = i / 10 % 10;                 // 123 / 10 = 12(整除)   12 %  10 = 2
18       int bai = i / 10 / 10 % 10;            // 123 / 10 = 12(整除)   12 /  10 = 1   1 % 10 = 1
19       if ((ge * ge * ge) + (shi * shi * shi) + (bai * bai * bai) == i) {
20         num ++;                              // 计数器思想
21         System.out.println(i + "就是一个水仙花数");
22       }
23     }
24     System.out.println("水仙花数的个数为" + num);
25
26   }
27 }

• while循环结构

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * 循环结构while语句的格式：
 5      *
 6       while循环的基本格式：
 7       while(判断条件语句) {
 8                  循环体语句;
 9       }
10
11             完整格式：
12
13             初始化语句
14       while(判断条件语句) {
15                 循环体语句;
16                 控制条件语句;
17       }
18      * B:执行流程：
19        * a:执行初始化语句
20        * b:执行判断条件语句,看其返回值是true还是false
21          * 如果是true，就继续执行
22          * 如果是false，就结束循环
23        * c:执行循环体语句;
24        * d:执行控制条件语句
25        * e:回到B继续。
26      * C:案例演示
27        * 需求：请在控制台输出数据1-10
28      */
29     int i = 0;
30     while (i < 11) {
31       i++;
32       System.out.println("i = " + i);
33     }
34
35   }
36 }

    循环结构while语句的练习

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:求和思想
 5        * 求1-100之和
 6      * B:统计思想
 7        * 统计”水仙花数”共有多少个
 8      */
 9     // 求1-100之和
10     int i = 0;
11     int sum = 0;
12     while (i < 101) {
13       sum += i;
14       i++;
15     }
16     System.out.println("sum = " + sum);
17
18     // 统计”水仙花数”共有多少个
19     int count = 0;
20     int j = 100;
21     while (j < 1000) {
22       int ge = j % 10;                 // 123 % 10 = 3
23       int shi = j / 10 % 10;           // 123 / 10 = 12   12 % 10 = 1
24       int bai = j / 10 / 10 % 10;      // 1 % 10 = 1
25       if ((ge * ge * ge) + (shi * shi * shi) + (bai * bai * bai) == j) {
26         count++;
27       }
28       j++;
29     }
30     System.out.println("水仙花的个数为： " + count);
31   }
32 }

• do...while循环结构

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:循环结构do...while语句的格式：
 5      *
 6       do {
 7          循环体语句;
 8       }while(判断条件语句);
 9
10       完整格式；
11       初始化语句;
12       do {
13          循环体语句;
14          控制条件语句;
15       }while(判断条件语句);
16      * B:执行流程：
17        * a:执行初始化语句
18        * b:执行循环体语句;
19        * c:执行控制条件语句
20        * d:执行判断条件语句,看其返回值是true还是false
21          * 如果是true，就继续执行
22          * 如果是false，就结束循环
23        * e:回到b继续。
24      * C:案例演示
25        * 需求：请在控制台输出数据1-10
26      */
27     // 请在控制台输出数据1-10
28     int i = 1;
29     do {
30       System.out.println("i = " + i);
31       i++;
32     } while (i < 11);
33   }
34 }

• 循环结构三种循环语句的区别

    三种循环语句的区别:

• do...while循环至少执行一次循环体。
• 而for,while循环必须先判断条件是否成立，然后决定是否执行循环体语句。

    for循环和while循环的区别：

• 如果你想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for循环。不知道用谁就用for循环。因为变量尽早的从内存中消失，可以提高内存的使用效率。

    

• 循环结构注意事项之死循环
• 一定要注意控制条件语句控制的那个变量的问题，不要弄丢了，否则就容易死循环。
• 两种最简单的死循环格式：
• while(true){...}
• for(; ;){...}

 

四、循环结构语句循环嵌套

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:案例演示
 5        * 需求：请输出一个4行5列的星星(*)图案。
 6        *
 7            如图：
 8         *****
 9         *****
10         *****
11         *****
12
13            注意：
14         System.out.println("*");和System.out.print("*");的区别
15      * B:结论：
16        * 外循环控制行数，内循环控制列数
17      */
18     for (int i = 1; i < 5; i++) {
19       for (int j = 1; j < 6; j++) {
20         System.out.print("*");
21       }
22       System.out.println();
23     }
24   }
25 }
26
27 public class JavaDemo {
28   public static void main(String[] args) {
29     /*
30      * A:案例演示
31            需求：请输出下列的形状
32       *
33       **
34       ***
35       ****
36       *****
37      */
38     for (int i = 1; i < 6; i++) {
39       for (int j = 1; j <= i; j++) {
40         System.out.print("*");
41       }
42       System.out.println();
43     }
44   }
45 }
46
47 public class JavaDemo {
48   public static void main(String[] args) {
49     /*
50      * A:案例演示
51        * 需求：在控制台输出九九乘法表。
52      * B:代码优化
53      *
54          注意：
55          '\x' x表示任意，\是转义符号,这种做法叫转移字符。
56
57          '\t'  tab键的位置
58          '\r'  回车
59          '\n'  换行
60          '\"'
61          '\''
62      */
63     int sum = 0;
64     for (int i = 1; i <= 9; i++) {
65       for (int j = 1; j <= i; j++) {
66         sum = i * j;
67         System.out.print(j + "*" + i + "=" + sum + "\t");
68       }
69       System.out.println();
70     }
71   }
72 }

五、控制跳转语句break语句

    break的使用场景：

• 只能在switch和循环中

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:break的使用场景
 5        * 只能在switch和循环中
 6      */
 7     for (int i = 0; i <= 10; i++) {
 8       if (i == 4) {
 9         break;         // 跳出循环
10       }
11       System.out.println("i =" + i);
12     }
13   }
14 }

六、控制跳转语句break语句

    continue的使用场景：

• 能在循环中

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * A:continue的使用场景
 5        * 只能在循环中
 6      */
 7     for (int i = 0; i <= 10; i++) {
 8       if (i == 4) {
 9         continue;         // 终止本次循环，继续下次循环
10       }
11       System.out.println("i =" + i);
12     }
13   }
14 }

六、控制跳转语句标号

    标号:标记某个循环对其控制

    标号组成规则:其实就是合法的标识符

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * 标号:标记某个循环对其控制
 5      * 标号组成规则:其实就是合法的标识符
 6      */
 7     outer: for (int i = 1; i <= 10; i++) {        // outer就是标号，只要是合法的标识符即可
 8       System.out.println("i =" + i);
 9       inner: for (int j = 1; j <= 10; j++) {
10         System.out.println("j = " + j);
11         break outer;
12       }
13     }
14     System.out.println("大家好");
15     /*
16      * http: 为标号
17      * //www.baidu.com 为单行注释
18      */
19     http://www.baidu.com
20     System.out.println("才是真的好");
21   }
22 }

七、控制跳转语句return语句

    返回

    其实它的作用不是结束循环的，而是结束方法的。

 1 public class JavaDemo {
 2   public static void main(String[] args) {
 3     /*
 4      * 返回
 5      * 其实它的作用不是结束循环的，而是结束方法的。
 6      */
 7     for (int i = 1; i <= 10; i++) {
 8       if (i == 4) {
 9         // break;              // 停止循环
10         return;                // 返回的意思，用来返回方法
11       }
12     }
13     System.out.println("hello world");
14   }
15 }

    return和break以及continue的区别：

• return是结束方法
• break是跳出循环
• continue是终止本次循环继续下次循环