原Java学习笔记005 - 流程控制

Posted 2020-09-01 iflytek

 1 package cn.temptation;
 2 
 3 public class Sample01 {
 4     public static void main(String[] args) {
 5         // 程序的流程控制（流程结构）：顺序结构、选择结构、循环结构
 6         
 7         // 顺序结构：从上向下，顺序执行
 8         System.out.println("出生...");
 9         System.out.println("享受人生...");
10         System.out.println("挂了...");
11     }
12 }

 1 package cn.temptation;
 2 
 3 public class Sample02 {
 4     public static void main(String[] args) {
 5         // 选择结构：1、if语句块； 2、switch语句块
 6         
 7         // if语句块
 8         
 9         // 形式1、if(比较表达式) { ... }
10         int i = 2;
11         
12 //        if (i != 3) {
13 //            System.out.println(i);
14 //        }
15         
16         // 注意：
17         // 1、比较表达式的结果必须是一个boolean类型的值
18         // 2、if语句如果不使用大括号，语法上可以；但是不使用大括号，if语句块只会影响其后的一行语句
19         
20 //        if (i != 3)
21 //            System.out.println(i);
22         
23         // 下面执行结果为2，3
24 //        if (i != 3) {
25 //            System.out.println(i);
26 //            System.out.println(++i);
27 //        }
28         
29         // 下面执行结果为2，3
30 //        if (i != 3) 
31 //            System.out.println(i);
32 //            System.out.println(++i);
33         
34         // 下面执行无结果
35 //        if (i == 3) {
36 //            System.out.println(i);
37 //            System.out.println(++i);
38 //        }
39         
40         // 下面执行结果为3，从执行结果得知，if无大括号的语句块后的第二行语句开始，就不再受if语句块的影响
41         if (i == 3) 
42             System.out.println(i);
43             System.out.println(++i);
44     }
45 }

 1 package cn.temptation;
 2 
 3 public class Sample03 {
 4     public static void main(String[] args) {
 5         // 形式2、if(比较表达式) { ... } else { ... }
 6         int i = 2;
 7         int j = 3;
 8 
 9         if (i == j) {
10             System.out.println("i等于j");
11         } else {
12             System.out.println("i不等于j");
13         }
14         
15         // 联想一下，这种形式的if结构（if...else结构）和 三元运算符的效果差不多
16     }
17 }

 1 package cn.temptation;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Sample04 {
 6     public static void main(String[] args) {
 7         // 需求：使用if...else...结构获取通过键盘录入的三个数字中最大的一个
 8         
 9         // 声明三个变量来接收键盘录入的数字
10         Scanner input = new Scanner(System.in);
11         // 一行中声明多个变量
12         int i, j, k;
13         System.out.println("输入第一个数字：");
14         i = input.nextInt();
15         System.out.println("输入第二个数字：");
16         j = input.nextInt();
17         System.out.println("输入第三个数字：");
18         k = input.nextInt();
19         input.close();
20         
21         // 使用if...else...结构比较这三个数字
22         int temp = 0;
23         int max = 0;
24         
25 //        // 写法1、分步操作
26 //        // ① 先把i、j进行比较得出较大的一个赋值给临时变量temp
27 //        if (i > j) {
28 //            temp = i;
29 //        } else {
30 //            temp = j;
31 //        }
32 //        
33 //        // ② 再把temp、k进行比较得出最大的一个赋值给最终变量max
34 //        if (temp > k) {
35 //            max = temp;
36 //        } else {
37 //            max = k;
38 //        }
39         
40         // 写法2、if...else...的嵌套
41         if (i > j) {
42             // 满足该条件时，说明i是i、j中较大的
43             if (i > k) {
44                 max = i;
45             } else {
46                 max = k;
47             }
48         } else {
49             // 满足该条件时，说明j是i、j中较大的
50             if (j > k) {
51                 max = j;
52             } else {
53                 max = k;
54             }
55         }
56         
57         System.out.println("输入的数字为：" + i + "," + j + "," + k + "中，最大的一个数字为：" + max);
58     }
59 }

 1 package cn.temptation;
 2 
 3 public class Sample05 {
 4     public static void main(String[] args) {
 5         // 形式3
 6         // if(比较表达式) { ... }
 7         // else if(比较表达式) { ... }
 8         // else if(比较表达式) { ... }
 9         // ...
10         // else { ... }
11         // 执行时，依次判断每一个比较表达式是否为true，如果为true，就执行该if语句块中的内容
12         
13         // 注意：else if之间有一个空格
14         
15         int i = 2;
16         
17 //        if (i == 3) {
18 //            System.out.println("i等于3");
19 //        } else if (i == 5) {
20 //            System.out.println("i等于5");
21 //        } else {
22 //            System.out.println("i等于其他值");
23 //        }
24         
25         // 注意：如果多个比较表达式均为true（多个条件均成立），那么会执行第1个为true的if语句块中的内容
26         //        后续为true的if语句块不会再走入了
27 //        if (i < 3) {
28 //            System.out.println("i小于3");
29 //        } else if (i < 5) {
30 //            System.out.println("i小于5");
31 //        } else {
32 //            System.out.println("i等于：" + i);
33 //        }
34         
35         if (i < 5) {
36             System.out.println("i小于5");
37         } else if (i < 3) {
38             System.out.println("i小于3");
39         } else {
40             System.out.println("i等于：" + i);
41         }
42     }
43 }

 1 package cn.temptation;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Sample06 {
 6     public static void main(String[] args) {
 7         // 需求：根据键盘录入的数字，判断输入的数字为奇数还是偶数？（分别使用if结构 和 三元运算符实现）
 8         Scanner input = new Scanner(System.in);
 9         System.out.println("输入一个数字：");
10         int i = input.nextInt();
11         input.close();
12         
13         // 写法1、使用if结构
14 //        if (i % 2 == 0) {
15 //            System.out.println("该数为偶数");
16 //        } else {
17 //            System.out.println("该数为奇数");
18 //        }
19         
20         // 写法2、三元运算符
21         // 因为三元运算符 和 if...else...结构的相近，考虑直接把if...else结构中的语句放到三元运算符中，这是生搬硬套，语法出错
22 //        (i % 2 == 0) ? (System.out.println("该数为偶数")) : (System.out.println("该数为奇数"));
23         
24         // 变通写法1、本质上和写法1是一样的
25 //        boolean result = (i % 2 == 0) ? true : false;
26 //        if (result) {
27 //            System.out.println("该数为偶数");
28 //        } else {
29 //            System.out.println("该数为奇数");
30 //        }
31         
32         // 变通写法2、纯粹使用三元运算符
33         // 根据是否为偶数获取相应的字符串
34         String msg = (i % 2 == 0) ? "该数为偶数" : "该数为奇数";
35         // 输出字符串的内容
36         System.out.println(msg);
37     }
38 }

 1 package cn.temptation;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Sample07 {
 6     public static void main(String[] args) {
 7         // 需求：根据键盘录入的分数数字，判断输入的分数是优秀（90~100）、良好（80~89）、及格（60~79）、不及格（0~59）
 8         Scanner input = new Scanner(System.in);
 9         System.out.println("输入一个分数：");
10         int score = input.nextInt();
11         input.close();
12         
13         // 下句表示范围的写法是错误的，画个数轴看一下
14 //        if (score >= 90 || score <= 100) {
15         if (score >= 90 && score <= 100) {
16             System.out.println("优秀");
17         } else if (score >= 80 && score <= 89) {
18             System.out.println("良好");
19         } else if (score >= 60 && score <= 79) {
20             System.out.println("及格");
21         } else if (score >= 0 && score <= 59) {
22             System.out.println("不及格");
23         } else {
24             System.out.println("输入的分数应该在【0~100】之间");
25         }
26         
27         // 注意：仔细看看需求，其实隐含了一个条件：即分数的范围是在0~100之间
28     }
29 }

 1 package cn.temptation;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Sample08 {
 6     public static void main(String[] args) {
 7         // 需求：根据键盘录入的月份数字，判断是哪一个季节？（3~5月为春季，6~8月为夏季，9~11月为秋季，12~2月为冬季）
 8         Scanner input = new Scanner(System.in);
 9         System.out.println("输入一个月份：");
10         int month = input.nextInt();
11         input.close();
12         
13         // 写法1
14         if (month >= 3 && month <= 5) {
15             System.out.println("Spring");
16         } else if (month >= 6 && month <= 8) {
17             System.out.println("Summer");
18         } else if (month >= 9 && month <= 11) {
19             System.out.println("Autumn");
20         // 下句写法没有满足条件的数字
21 //        } else if (month >= 12 && month <= 2) {
22         } else if (month == 12 || month == 1 || month == 2) {
23             System.out.println("Winter");
24         } else {
25             System.out.println("输入的月份应该在【1~12】之间");
26         }
27         
28         // 写法2
29         int result = month / 3;
30         
31         if (month == 0 || month == 13 || month == 14 || result < 0 || result > 4) {
32             System.out.println("输入的月份应该在【1~12】之间");
33         } else if (result < 1) {
34             System.out.println("Winter");
35         } else if (result < 2) {
36             System.out.println("Spring");
37         } else if (result < 3) {
38             System.out.println("Summer");
39         } else if (result < 4) {
40             System.out.println("Autumn");
41         } else {
42             System.out.println("Winter");
43         }
44         
45         // 编写代码及测试时，要充分考虑，特别是边界值，考虑时不要遗漏
46     }
47 }

 1 package cn.temptation;
 2 
 3 public class Sample09 {
 4     public static void main(String[] args) {
 5         // 选择结构：switch结构
 6         
 7 //        switch (变量) {
 8 //        case 值1:
 9 //            break;
10 //        case 值2:
11 //            break;
12 //        ...
13 //        case 值n:
14 //            break;
15 //        default:
16 //            break;
17 //        }
18         
19         // 注意：
20         // 1、switch后括号中的内容有一些限制：byte、short、int、long、char
21         //        JDK 5后可以使用枚举；JDK 7后可以使用字符串类型
22         // 2、case：后面的值拿来和switch括号中的内容进行比较的，当比较结果为true时，会执行该case语句块中的内容
23         // 3、break：英文是中断的意思，也就是说后续都不做了，作用范围到switch右侧的大括号为止
24         // 4、default：英文是默认的意思，如果case条件的值都不能匹配switch括号中的值，那么执行default语句块中的内容
25         // 5、switch结构中可以没有default部分，但是要求加上default部分
26         // 6、switch结构中可以只有default部分，表示默认就执行该default语句块中的内容
27         
28         int i = 2;
29         
30         switch (i) {
31         case 1:
32             System.out.println("i等于1");
33             break;
34         case 2:
35             System.out.println("i等于2");
36             break;
37         case 3:
38             System.out.println("i等于3");
39             break;
40         default:
41             System.out.println("i等于其他值");
42             break;
43         }
44         
45         System.out.println("这里不会收到switch结构中的break语句的影响");
46         
47         switch (i) {
48         default:
49             System.out.println("switch结构中只有default部分");
50             break;
51         }
52     }
53 }

 1 package cn.temptation;
 2 
 3 import java.util.Scanner;
 4 
 5 public class Sample10 {
 6     public static void main(String[] args) {
 7         // 注意：
 8         // 1、case部分的值不能重复，否则有语法错误：Duplicate case
 9         // 2、default部分不是非得放在switch结构中的最后，可以放在任何和case同级的位置，只是习惯性的放在最后
10         // 3、放在最后的default部分，可以不写break语句，但是建议写上
11         
12         // 需求：根据键盘录入的数字，使用switch结构判断是星期几
13         Scanner input = new Scanner(System.in);
14         System.out.println("输入一个数字作为星期几：");
15         int weekDay = input.nextInt();
16         input.close();
17         
18         switch (weekDay) {
19         // default部分可以放在switch结构的最前端
20 //        default:
21 //            System.out.println("输入不正确");
22 //            break;
23         case 1:
24             System.out.println("Monday");
25             break;
26         case 2:
27             System.out.println("Tuesday");
28             break;
29         // default部分可以放在switch结构的任意位置
30 //        default:
31 //            System.out.println("输入不正确");
32 //            break;
33         case 3:
34             System.out.println("Wednesday");
35             break;
36         case 4:
37             System.out.println("Thursday");
38             break;
39         case 5:
40             System.out.println("Friday");
41             break;
42         case 6:
43             System.out.println("Saturday");
44             break;
45         case 7:
46             System.out.println("Sunday");
47             break;
48         default:
49             System.out.println("输入不正确");
50             // 写在最后的default部分中的break语句可以省略不写
51 //            break;
52         }
53     }
54 }

 1 package cn.temptation;
 2 
 3 public class Sample11 {
 4     public static void main(String[] args) {
 5         // switch结构在JDK 7后支持字符串，case后就可以使用字符串
 6         String course = "Java";
 7         
 8         switch (course) {
 9         case "android":
10             System.out.println("Android是主流的移动开发平台");
11             break;
12         case "Java":
13             System.out.println("Java真简单");
14             break;
15         case "mysql":
16             System.out.println("MySQL是主流的数据库");
17             break;
18         default:
19             System.out.println("想混口饭吃，总得会一样！");
20             break;
21         }
22     }
23 }

 1 package cn.temptation;
 2 
 3 public class Sample12 {
 4     public static void main(String[] args) {
 5         // 特别注意：
 6         // switch结构中，case部分需要结合break语句使用，如果只写case部分不写其相应的break语句，会发生"case击穿"现象
 7         // 如果case部分没有相应的break语句，当该case条件满足时，执行该case部分的语句内容，并一直向下执行（无视其他case条件），直到遇见break为止
 8         // 如果一直没有遇见break，以switch右侧的大括号（switch结构作用域右侧的边界）作为执行结束的依据
 9         
10         int i = 2;
11         
12         switch (i) {
13         case 1:
14             System.out.println("i等于1");
15             break;
16         case 2:
17             System.out.println("i等于2");
18         case 3:
19             System.out.println("i等于3");
20 //            break;
21         default:
22             System.out.println("i等于其他值");
23             break;
24         }
25         
26         System.out.println("这里会不会被执行到？");
27     }
28 }

 1 package cn.temptation;
 2 
 3 public class Sample13 {
 4     public static void main(String[] args) {
 5         int i = 2;
 6         
 7         // 问题1
 8 //        switch (i) {
 9 //        default:
10 //            i++;
11 //            break;
12 //        case 2:
13 //            ++i;
14 //            break;
15 //        case 3:
16 //            ++i;
17 //            break;
18 //        case 4:
19 //            ++i;
20 //            break;
21 //        }
22 //        
23 //        System.out.println(i);    // 3
24         
25         // default部分放在switch结构的最前面，也不会第一个执行，也优先匹配case条件
26         
27         // 问题2
28         switch (i) {
29         default:
30             i++;
31         case 3:
32             ++i;
33         case 4:
34             ++i;
35         }
36         
37         System.out.println(i);
38     }
39 }

  1 package cn.temptation;
  2 
  3 import java.util.Scanner;
  4 
  5 public class Sample14 {
  6     public static void main(String[] args) {
  7         // 需求：根据键盘录入的数字，判断是什么季节？（分别使用if结构 和 switch结构）
  8         Scanner input = new Scanner(System.in);
  9         System.out.println("输入一个月份：");
 10         int month = input.nextInt();
 11         input.close();
 12         
 13         // 写法1、if结构
 14         if (month >= 3 && month <= 5) {
 15             System.out.println("Spring");
 16         } else if (month >= 6 && month <= 8) {
 17             System.out.println("Summer");
 18         } else if (month >= 9 && month <= 11) {
 19             System.out.println("Autumn");
 20         } else if (month == 12 || month == 1 || month == 2) {
 21             System.out.println("Winter");
 22         } else {
 23             System.out.println("输入的月份应该在【1~12】之间");
 24         }
 25         
 26         // 写法2、switch结构
 27 //        switch (month) {
 28 //        case 1:
 29 //            System.out.println("Winter");
 30 //            break;
 31 //        case 2:
 32 //            System.out.println("Winter");
 33 //            break;
 34 //        case 3:
 35 //            System.out.println("Spring");
 36 //            break;
 37 //        case 4:
 38 //            System.out.println("Spring");
 39 //            break;
 40 //        case 5:
 41 //            System.out.println("Spring");
 42 //            break;
 43 //        case 6:
 44 //            System.out.println("Summer");
 45 //            break;
 46 //        case 7:
 47 //            System.out.println("Summer");
 48 //            break;
 49 //        case 8:
 50 //            System.out.println("Summer");
 51 //            break;
 52 //        case 9:
 53 //            System.out.println("Autumn");
 54 //            break;
 55 //        case 10:
 56 //            System.out.println("Autumn");
 57 //            break;
 58 //        case 11:
 59 //            System.out.println("Autumn");
 60 //            break;
 61 //        case 12:
 62 //            System.out.println("Winter");
 63 //            break;
 64 //        default:
 65 //            System.out.println("输入的月份应该在【1~12】之间");
 66 //            break;
 67 //        }
 68         
 69         // 因为switch结构中的很多case条件都做的是相同的事情，所以考虑优化一下写法
 70         // 考虑把做相同事情的case条件合并到一起，使用case击穿，这样可以省略一些重复的代码
 71         switch (month) {
 72         case 12:
 73         case 1:
 74         case 2:
 75             System.out.println("Winter");
 76             break;
 77         // 下句写法语法错误：The operator || is undefined for the argument type(s) int, int
 78 //        case 3 || 4 || 5:
 79         case 3:
 80         case 4:
 81         case 5:
 82             System.out.println("Spring");
 83             break;
 84         case 6:
 85         case 7:
 86         case 8:
 87             System.out.println("Summer");
 88             break;
 89         case 9:
 90         case 10:
 91         case 11:
 92             System.out.println("Autumn");
 93             break;
 94         default:
 95             System.out.println("输入的月份应该在【1~12】之间");
 96             break;
 97         }
 98     }
 99     // if结构 和 switch结构的区别：
100     // 1、if结构的括号内使用的是比较表达式，得到的结果是boolean类型的值
101     // 2、switch结构的case后面跟的是用来匹配的值
102     
103     // if结构 和 switch结构的选择：
104     // 1、if结构用于条件描述的范围比较大的场合
105     // 2、switch结构用于少量的有特定的值进行比较的场合
106 }