Java复习整理 02

 1 package demo01;
 2 
 3 import java.util.Scanner;
 4 
 5 public class ScannerDemo01 {
 6     public static void main(String[] args) {
 7         //创建引用类型变量
 8         Scanner sc = new Scanner(System.in);
 9         //获取数字
10         System.out.println("请输入一个数字！");
11         int n = sc.nextInt();
12         System.out.println("你输入的数字是："+n);
13         //获取浮点
14         System.out.println("请输入一个小数！");
15         double d = sc.nextDouble();
16         System.out.println("你输入的数字是："+d);
17         //获取一个字符串
18         System.out.println("输入一行字符串！");
19         String str = sc.next();
20         System.out.println("你输入的字符串是"+str);
21     }
22 }

 1 package com.demo_scanner;
 2 
 3 /*
 4     案例: 演示Scanner入门.
 5 
 6     作用:
 7         就是为了接收用户录入的数据, 让我们的程序(代码)更加灵活.
 8     使用步骤:
 9         1. 导包.      写在package 和 class 之间.
10             import java.util.Scanner;
11         2. 创建对象.  面向对象部分详解, 目前先照着做.
12             Scanner sc = new Scanner(System.in);
13         3. 通过Scanner类中的nextInt()方法, 获取用户录入的数字.
14             int num = sc.nextInt();
15  */
16 
17 import java.util.Scanner;
18 
19 public class Demo01 {
20     public static void main(String[] args) {
21         //1.提示用户录入他/她的年龄.
22         System.out.println("请录入您的年龄: ");
23         //2.通过键盘录入功能, 接收用户录入的年龄.
24         //2.1 创建键盘录入对象
25         Scanner sc = new Scanner(System.in);
26         //2.2 接收用户录入的年龄
27         int age = sc.nextInt();
28         //3.将用户录入的数据(年龄)打印到控制台上.
29         System.out.println(age);
30     }
31 }

 1 package demo02;
 2 
 3 import java.util.Random;
 4 
 5 public class RandomDemo {
 6     public static void main(String[] args) {
 7         //创建一个实体类
 8         Random r = new Random();
 9         //得到一个0-100 不包括100的随机数
10         int i = r.nextInt(100);
11         System.out.println(i);
12         //得到一个0-1 不包括1的随机数
13         double d = r.nextDouble();
14         System.out.println(d);
15     }
16 }

 1 package demo03;
 2 
 3 public class IfDemo {
 4     public static void main(String[] args) {
 5         int x = 5;
 6         if(x <10)
 7             x++;
 8         System.out.println(x);
 9     }
10 }

 1 package com.it.demoif;
 2 
 3 /*
 4     案例: 演示Java中的流程控制语句.
 5 
 6     概述:
 7         大白话翻译: 就是用来控制Java中代码的执行顺序的, 有些代码是满足特定条件的情况下才能被执行, 有些代码是在某在条件下重复执行的,
 8         这些都要用到 流程控制语句.
 9 
10     分类:
11         顺序结构:
12             它是Java代码的默认结构, 即: 代码会按照从上往下, 从左往右的顺序来依次逐行执行.
13 
14         分支结构:
15 
16         循环结构:
17  */
18 public class Demo01 {
19     public static void main(String[] args) {
20         System.out.println("start");
21         System.out.println(1);
22         System.out.println(2);
23         System.out.println(3);
24 
25         //演示每行代码的执行都是按照从左往右的顺序执行的.
26         System.out.println(10 + 10 + "hello" + 10 + 10);
27         System.out.println("end");
28     }
29 }

 1 package demo_if;
 2 
 3 /*
 4     案例: 演示if语句之 单分支.
 5 
 6     涉及到的知识点:
 7         分支结构的分类:
 8             if语句                //一般用于 范围 的判断.
 9             switch.case语句       //一般用于 固定值 的判断.
10 
11         if语句详解:
12             概述: if语句根据需求不同, 分支个数也不同, 主要分为以下三种:
13                 单分支:    if语句
14                 双分支:    if.else语句
15                 多分支:    if.else if语句
16             单分支格式和执行流程:
17                 格式:
18                     if(关系表达式) {
19                         语句体;
20                     }
21                 执行流程:
22                     1. 先执行关系表达式, 看起结果是true还是false.
23                     2. 如果是true, 则执行对应的语句体, 如果是false, 则什么都不执行.
24  */
25 public class Demo02 {
26     public static void main(String[] args) {
27         //需求: 定义变量time表示时间, 如果它的范围是在[0,8]之间, 就打印早上好, 否则不操作.
28         //1. 定义变量time表示时间.
29         int time = 6;
30         //2. 如果它的范围是在[0,8]之间, 就打印早上好
31         if (time >= 0 && time < 8) {    //0 <= time  <= 8
32             System.out.println("早上好");
33         }
34     }
35 }

 1 package demo03;
 2 
 3 public class IfDemo02 {
 4     public static void main(String[] args) {
 5         int num = 19;
 6         if(num % 2 == 0){
 7             //判断条件成立，num 2 整除
 8             System.out.println("num 是一个偶数！");
 9             
10         }else
11         {
12             System.out.println("num 是一个奇数！");
13         }
14     }//欢迎加入Java开发交流君样：909038429
15 
16 }

 1 package demo_if;
 2 
 3 /*
 4     案例: 演示if语句之 双分支.
 5 
 6     涉及到的知识点:
 7         双分支格式和执行流程:
 8             格式:
 9                 if(关系表达式) {
10                     语句体1;
11                 } else {
12                     语句体2;
13                 }
14             执行流程:
15                 1. 先执行关系表达式, 看起结果是true还是false.
16                 2. 如果是true, 则执行对应的语句体1, 如果是false, 则执行对应的语句体2;
17  */
18 public class Demo03 {
19     public static void main(String[] args) {
20         //需求: 定义变量time表示时间, 如果它的范围是在0~8之间, 就打印早上好, 否则就打印中午好.
21 
22         //1. 定义变量time表示时间
23         int time = 15;
24         //2. 判断它的范围是否在0~8之间, 在: 就打印早上好
25         if (time >= 0 && time < 8) {
26             System.out.println("早上好");
27         } else {
28             //3. 不在: 就打印中午好
29             System.out.println("中午好");
30         }
31     }
32 }

 1 package demo03;
 2 
 3 public class IfDemo03 {
 4     public static void main(String[] args) {
 5         int grade = 75;
 6         if(grade > 80){
 7             System.out.println("该成绩的等级为优");
 8         }else if(grade > 70){
 9             System.out.println("该成绩的等级为良");
10         }else if(grade > 60){
11             System.out.println("该成绩的等级为中");
12         }else{
13             System.out.println("该成绩的等级为差");
14         }
15     }
16 }

 1 package demo_if;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6     案例: 演示if语句的多分支结构.
 7 
 8     格式:
 9         if(关系表达式1) {
10             //语句体1;
11         } else if(关系表达式2){
12             //语句体2;
13         } else if(关系表达式3){    //这里可以根据需求, 有多个else if语句
14             //语句体3;
15         } else {
16             //语句体n;
17         }
18 
19     执行流程:
20         1. 执行关系表达式1, 看其结果是true 还是 false.
21         2. 如果是true, 则执行 对应的语句体1, 然后if语句结束.
22         3. 如果是false, 则执行关系表达式2, 看其结果是true 还是 false.
23            如果是true, 则执行 对应的语句体2, 然后if语句结束.
24         4. 如果是false, 则执行关系表达式3....    以下省略.
25         5. 如果所有的关系表达式都不成立, 则执行 语句体n.
26 
27    需求:
28     1.提示用户录入[1, 7]之间的数字, 并接收.
29     2.根据用户录入的数字, 打印对应的星期, 格式如下:
30         –用户录入1, 打印"星期一"
31         –用户录入2, 打印"星期二"
32         –...以此类推
33         –用户录入非法数字, 打印"没有这样的日期"
34  */
35 public class Demo04 {
36     public static void main(String[] args) {
37         //1. 创建键盘录入对象.
38         Scanner sc = new Scanner(System.in);
39         //2. 提示用户录入[0-7]之间的数字.
40         System.out.println("请录入[0-7]之间的任意整数: ");
41         //3. 接收用户录入的数字.
42         int week = sc.nextInt();
43         //4. 判断用户录入的数字的结果, 并打印对应的星期.
44         if (week == 1) {
45             System.out.println("星期一");
46         } else if (week == 2) {
47             System.out.println("星期二");
48         } else if (week == 3) {
49             System.out.println("星期三");
50         } else if (week == 4) {
51             System.out.println("星期四");
52         } else if (week == 5) {
53             System.out.println("星期五");
54         } else if (week == 6) {
55             System.out.println("星期六");
56         } else if (week == 7) {
57             System.out.println("星期日");
58         } else {
59             System.out.println("没有这样的星期");
60         }
61     }
62 }

 1 package demo_switch;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6     案例: switch案例入门, 根据月份打印对应的季节.
 7 
 8     需求:
 9         1.一年有12个月, 分属于春夏秋冬4个季节, 键盘录入一个月份, 请用程序实现判断该月份属于哪个季节, 并输出。
10         2.具体标准如下:
11         –输入： 1、2、12 输出：冬季
12         –输入： 3、4、5 输出：春季
13         –输入： 6、7、8 输出：夏季
14         –输入： 9、10、11 输出：秋季
15         –输入：其它数字 输出：数字有误
16 
17     switch详解:
18         概述:
19             它属于分支结构, 一般用于做 固定值 的校验.
20         格式:
21             switch(表达式) {       //JDK1.5以前: byte, short, char, int,  JDK1.5: 枚举,  JDK1.7: 字符串.
22                 case 值1:
23                     语句体1;
24                     break;         //看到break, 整个switch语句就执行结束了.
25                 case 值2:
26                     语句体2;
27                     break;
28                 ...               //根据需求可以有多个case
29                 default:          //如果所有的case语句都不匹配, 则执行default中的内容.
30                     语句体n;
31                     break;
32             }
33  */
34 public class Demo01 {
35     public static void main(String[] args) {
36         /*
37             输入： 1、2、12 输出：冬季
38             输入： 3、4、5 输出：春季
39             输入： 6、7、8 输出：夏季
40             输入： 9、10、11 输出：秋季
41             输入：其它数字 输出：数字有误
42          */
43         //1. 创建键盘录入对象.
44         Scanner sc = new Scanner(System.in);
45         //2. 提示用户录入月份, 并接收.
46         System.out.println("请录入一个月份: ");
47         int month = sc.nextInt();
48 
49         //3. 根据用户录入的月份, 打印对应的季节.  可以用if做, 也可以用switch做.
50         switch (month) {     //我们要根据month的值, 来决定执行哪里的代码.
51             case 12:
52                 System.out.println("冬季");
53                 break;
54             case 1:
55                 System.out.println("冬季");
56                 break;
57             case 2:
58                 System.out.println("冬季");
59                 break;
60             case 3:
61                 System.out.println("春季");
62                 break;
63             case 4:
64                 System.out.println("春季");
65                 break;
66             case 5:
67                 System.out.println("春季");
68                 break;
69             case 6:
70                 System.out.println("夏季");
71                 break;
72             case 7:
73                 System.out.println("夏季");
74                 break;
75             case 8:
76                 System.out.println("夏季");
77                 break;
78             case 9:
79                 System.out.println("秋季");
80                 break;
81             case 10:
82                 System.out.println("秋季");
83                 break;
84             case 11:
85                 System.out.println("秋季");
86                 break;
87             default:
88                 System.out.println("没有这样的月份, 你是从火星来的吧?");
89                 break;
90         }
91     }
92 }

 1 package demo_switch;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6     案例: 演示switch的 case穿透现象.
 7 
 8     case穿透解释:
 9         当switch语句的表达式的值 和 某一个case的值匹配上后, 回去执行该case对应的语句体, 正常情况下应该是每个case语句都有break,
10         当看到break, 整个switch语句就结束了. 但是如果没有遇到break, 则switch语句会 在不判断case值的情况下, 一直往下执行,
11         直至switch语句执行结束, 或者遇到break, 才算完结, 这种情况就叫做: case穿透.
12 
13     需求:
14         1.一年有12个月, 分属于春夏秋冬4个季节, 键盘录入一个月份, 请用程序实现判断该月份属于哪个季节, 并输出。
15         2.具体标准如下:
16         –输入： 1、2、12 输出：冬季
17         –输入： 3、4、5 输出：春季
18         –输入： 6、7、8 输出：夏季
19         –输入： 9、10、11 输出：秋季
20         –输入：其它数字 输出：数字有误
21 
22     关于switch语句的思考题:
23         1.switch语句的小括号中, 可以放什么?
24             JDK1.5以前: byte, short, char, int
25             JDK1.5: 枚举
26             JDK1.7: 字符串
27         2.default语句必须放到switch语句的最后吗?
28             看需求, 一般都是放在最后的, 因为default类似于if.else语句的else语句, 它是用来做非法值校验的,
29             即: 当所有的case都不匹配, 才会执行default语句.
30         3.break关键字可以省略吗? 对执行结果是否有影响?
31             看需求, 最后一个break可以省略, 对结果没有任何影响,
32             如果是中间的break省略了, 可能会发生case穿透现象.
33  */
34 public class Demo02 {
35     public static void main(String[] args) {
36         /*
37             输入： 1、2、12 输出：冬季
38             输入： 3、4、5 输出：春季
39             输入： 6、7、8 输出：夏季
40             输入： 9、10、11 输出：秋季
41             输入：其它数字 输出：数字有误
42          */
43         //1. 创建键盘录入对象.
44         Scanner sc = new Scanner(System.in);
45         //2. 提示用户录入月份, 并接收.
46         System.out.println("请录入一个月份: ");
47         int month = sc.nextInt();
48 
49         //3. 根据用户录入的月份, 打印对应的季节.  可以用if做, 也可以用switch做.
50         switch (month) {     //我们要根据month的值, 来决定执行哪里的代码.
51             case 12:
52             case 1:
53             case 2:
54                 System.out.println("冬季");
55                 break;
56             case 3:
57             case 4:
58             case 5:
59                 System.out.println("春季");
60                 break;
61             case 6:
62             case 7:
63             case 8:
64