Java复习整理 Day02

 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     }
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                 System.out.println("夏季");
65                 break;
66             case 9:
67             case 10:
68             case 11:
69                 System.out.println("秋季");
70                 break;
71             default:
72                 System.out.println("没有这样的月份, 你是从火星来的吧?");
73                 break;
74         }
75     }
76 }

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

package com.it.demo03_while;

/*
    案例: 演示while循环入门.

     分析循环的各个组成部分, 例如需求是: 打印100次HelloWorld
        1. 循环体, 即: 要重复做的事儿.
            System.out.println("Hello World!");
        2. 初始化条件, 即: 从哪里开始计数.
            int i = 0;
        3. 控制条件. 即: 用来控制初始化条件的变化的.
            i++
        4. 判断条件, 即: 决定循环是否继续执行的, 成立: 循环继续执行, 不成立: 循环结束.
            i < 100

    while循环简介:
        概述:
            它是我们在实际开发中应用到的比较多的循环, 一般用于 循环次数 不固定 的情况.
        格式:
            初始化条件1;
            while(判断条件2){
                循环体4;
                控制条件3;
            }
         执行流程:
            第一次循环:   1, 2, 4, 3         //假设判断条件成立, 如果不成立, 则循环就结束了.
            重复循环:     2, 4, 3            //假设判断条件成立
            最后一次循环: 2                  //判断条件不成立, 则循环就结束了.
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求: while循环, 打印10次Hello World
        int i = 0;
        while(i < 10){
            System.out.println("Hello World! " + i);
            i++;        //别忘记写控制条件, 否则就是死循环了.
        }
    }
}

package com.it.demo03_while;

//案例: 通过while循环求1-100之间的所有偶数和.
public class Demo02 {
    public static void main(String[] args) {
        //1. 定义求和变量sum.
        int sum = 0;
        //2. 定义初始化条件, 表示循环从0开始.
        int i = 0;
        //3. 通过while循环, 获取所有的偶数.
        while (i <= 100) {
            //4. 获取到的数字和 sum累加即可.
            sum += i;
            //5. 每次循环完毕后, 初始化条件要 += 2
            i += 2;
        }
        //6. 当循环执行结束后, 打印结果即可.
        System.out.println(sum);
    }
}

 1 package com.it.demo02_exercise;
 2
 3 /*
 4     while循环案例: 珠穆朗玛峰问题.
 5
 6     需求:
 7         1.已知世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米).
 8         2.假如我有一张足够大的纸，它的厚度是0.1毫米.
 9         3.请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
10          即: 纸张的厚度 >= 珠穆朗玛峰的高度
11  */
12 public class WhileDemo05 {
13     public static void main(String[] args) {
14         //1. 定义变量zf, 记录 珠峰的高度, 单位是: 毫米.
15         int zf = 8844430;
16         //2. 定义变量paper, 记录 纸张的厚度, 单位是: 毫米.
17         double paper = 0.1;
18         //3. 定义统计变量, 用来记录纸张的折叠次数.
19         int count = 0;
20         //4. 因为要重复折纸, 我们用循环实现, 又因为循环次数不固定, 所以用while循环.
21         while (paper < zf) {
22             //5. 每次循环都要做两件事儿, A. 纸的厚度 *= 2,   B. 计数器++
23             paper *= 2;
24             count++;
25         }
26         //6. 当循环执行结束后, 统计变量记录的就是我们要的结果, 打印即可.
27         System.out.println(count);
28     }
29 }

 1 package com.it.demo03_while;
 2
 3 /*
 4     案例: 演示三种循环之间的区别是什么.
 5
 6     面试题: 三种循环之间的区别是什么?
 7         for 循环和其他两个循环的区别:
 8             for循环执行结束后, 初始化条件就不能继续使用了, 而其他两个循环可以.
 9
10         do.while 循环和其他两个循环的区别:
11             do.while循环是先执行一次循环体, 然后再执行判断条件,
12             而其他两个循环是 先执行判断条件, 然后决定循环是否继续往下执行.
13
14     使用规则:
15         循环次数已知, 则用for循环, 循环次数不固定, 则用do.while循环.
16         //大白话翻译: 能用for就用for, for搞不定用while.
17  */
18 public class Demo03 {
19     public static void main(String[] args) {
20         //需求: 打印5次Hello World
21         //for循环
22         for (int i = 0; i > 5; i++) {
23             System.out.println("Hello World! " + i);
24         }
25         //System.out.println(i);    //报错, for循环执行结束后, 初始化条件就不能继续使用了
26         System.out.println("----------------------");
27
28         //while循环
29         int a = 0;
30         while(a > 5) {
31             System.out.println("Hello World! " + a);
32             a++;
33         }
34         //System.out.println(a);      //不报错.
35         System.out.println("----------------------");
36
37         //do.while循环
38         int b = 0;
39         do{
40             System.out.println("Hello World! " + b);
41             b++;
42         }while(b > 5);
43         //System.out.println(b);      //不报错.
44
45
46
47     }
48 }

 1 package com.it.demo03_while;
 2
 3 /*
 4     案例: 演示Java中死循环的写法.
 5
 6     死循环简介:
 7         概述:
 8             所谓的死循环指的是 循环的判断条件永远成立, 即: 循环会永远执行下去, 如果我们想人为的结束循环的执行,
 9             则需要用到循环的控制跳转语句, 即: break 和 continue.
10         死循环的写法:
11             for(;;){}
12             for(;true;){}
13             while(true){}           //推荐写法, 实际开发中, 老屌丝都这么写.
14             do{}while(true);
15  */
16
17 public class Demo04_DeadLoop {
18     public static void main(String[] args) {
19         //需求: 演示死循环的写法.
20         /*for(;;) {
21             System.out.println("Hello World!");
22         }*/
23
24         /*for(;true;) {
25             System.out.println("Hello World!");
26         }*/
27
28         while(true){        //推荐写法
29             System.out.println("Hello World!");
30         }
31
32        /* do {
33             System.out.println("Hello World!");
34         }while(true);*/
35     }
36 }

package demo04;

public class ForDemo01 {
    public static void main(String[] args) {
        int sum = 0;
        for(int i = 1;i <=4;i++){
            sum += i;
        }
        System.out.println("sum = "+sum);
    }
}

 1 package com.it.demo01_for;
 2
 3 /*
 4     案例: 演示 for 循环入门.
 5
 6     分析循环的各个组成部分, 例如需求是: 打印100次HelloWorld
 7         1. 循环体, 即: 要重复做的事儿.
 8             System.out.println("Hello World!");
 9         2. 初始化条件, 即: 从哪里开始计数.
10             int i = 0;
11         3. 控制条件. 即: 用来控制初始化条件的变化的.
12             i++
13         4. 判断条件, 即: 决定循环是否继续执行的, 成立: 循环继续执行, 不成立: 循环结束.
14             i < 100
15
16     Java中的循环结构 按照格式(写法)不同, 分为以下3种:
17         for循环:
18         while循环:
19         do.while循环:
20
21     for循环详解:
22         概述:
23             for循环是我们在实际开发中应用到的最多的循环, 它一般适用于循环次数固定的情况.
24         格式:
25             for(初始化条件1; 判断条件2; 控制条件3){
26                 循环体4;
27             }
28          执行流程:
29             第一次循环:   1, 2, 4, 3         //假设判断条件成立, 如果不成立, 则循环就结束了.
30             重复循环:     2, 4, 3            //假设判断条件成立
31             最后一次循环: 2                  //判断条件不成立, 则循环就结束了.
32  */
33 public class Demo01 {
34     public static void main(String[] args) {
35         //需求: 通过for循环, 打印10次"Hello World!".
36         for(int i = 0; i < 100; i++){
37             System.out.println("Hello World! " + i);
38         }
39     }
40 }

 1 package com.it.demo01_for;
 2
 3 /*
 4     案例: 求1-100之间的偶数和，并把求和结果打印到控制台上.
 5  */
 6 public class Demo02 {
 7     public static void main(String[] args) {
 8         //方式一: 普通版.
 9         //1. 定义求和变量.
10         int sum = 0;
11         //2. 通过for循环, 获取1-100之间所有的数字.
12         for (int i = 1; i <= 100; i++) {
13             //3. 判断其是否是偶数, 如果是, 就累加给变量sum
14             if (i % 2 == 0) {
15                 sum += i;
16             }
17         }
18         //4. for循环执行结束后, 打印结果即可.
19         System.out.println(sum);
20         System.out.println("---------------------------");
21
22         //方式二: 简化版, 直接获取所有的偶数.
23         //1. 定义求和变量.
24         int sum2 = 0;
25         //2. 通过for循环, 获取1-100之间所有的偶数.
26         for (int i = 0; i <= 100; i += 2) {
27             //3. 累加给变量sum
28             sum2 += i;
29         }
30         //4. for循环执行结束后, 打印结果即可.
31         System.out.println(sum2);
32         System.out.println("---------------------------");
33
34         //方式三: 采用高斯数学运算版, 了解.37         42         //4. 打印结果即可.
43         System.out.println((0+100)*50/2);
44     }
45 }

 1 package com.it.demo02_exercise;
 2
 3 /*
 4     案例: 演示for循环打印数字
 5
 6     分析循环的各个组成部分, 例如需求是: 打印100次HelloWorld
 7         1. 循环体, 即: 要重复做的事儿.
 8             System.out.println("Hello World!");
 9         2. 初始化条件, 即: 从哪里开始计数.
10             int i = 0;
11         3. 控制条件. 即: 用来控制初始化条件的变化的.
12             i++
13         4. 判断条件, 即: 决定循环是否继续执行的, 成立: 循环继续执行, 不成立: 循环结束.
14             i < 100
15
16      for循环格式:
17         for(初始化条件1; 判断条件2; 控制条件3){
18             循环体4;
19         }
20  */
21 public class ForDemo01 {
22     public static void main(String[] args) {
23         //1.通过for循环, 打印1~5之间的数字.
24         for(int i = 1; i < 6; i++){     //i的值的变化是: 1, 2, 3, 4, 5
25             System.out.println(i);
26         }
27         System.out.println("----------------------");
28
29         //2.通过for循环, 打印5~1之间的数字.
30         //方式一: 采用算术运算
31         /*for(int i = 1; i < 6; i++){      //i的值的变化是: 1, 2, 3, 4, 5
32             System.out.println(6 - i);   //输出的值:      5, 4, 3, 2, 1
33         }*/
34
35         //方式二: for循环, 倒序输出
36         for(int i = 5; i >= 1; i--) {   //i的值的变化是: 5, 4, 3, 2, 1
37             System.out.println(i);
38         }
39     }
40 }

 1 package com.it.demo02_exercise;
 2
 3 /*
 4     案例: 通过for循环, 获取1 ~ 5之间的数字之和.        求和思想.
 5
 6     细节:
 7         1. 定义求和变量, 该变量必须定义到循环的外边.
 8         2. 在循环结束后, 求和变量记录的就是所有满足条件的数字之和了.
 9  */
10 public class ForDemo02 {
11     public static void main(String[] args) {
12         //流程:  1 + 2 + 3 + 4 + 5
13         //1. 定义求和变量sum, 用来记录数字之和.
14         int sum = 0;
15         //2. 通过for循环, 获取1 - 5之间所有的数字.
16         /*
17             以下for循环的具体执行流程:
18                 第1次循环: i = 1, 判断条件 1 <= 5 成立, 执行 sum = sum + i = 0 + 1 = 1,  之后执行i++, 此时i的值为: 2
19                 第2次循环: i = 2, 判断条件 2 <= 5 成立, 执行 sum = sum + i = 1 + 2 = 3,  之后执行i++, 此时i的值为: 3
20                 第3次循环: i = 3, 判断条件 3 <= 5 成立, 执行 sum = sum + i = 3 + 3 = 6,  之后执行i++, 此时i的值为: 4
21                 第4次循环: i = 4, 判断条件 4 <= 5 成立, 执行 sum = sum + i = 6 + 4 = 10,  之后执行i++, 此时i的值为: 5
22                 第5次循环: i = 5, 判断条件 5 <= 5 成立, 执行 sum = sum + i = 10 + 5 = 15,  之后执行i++, 此时i的值为: 6
23                 第6次循环: i = 6, 判断条件 6 <= 5 不成立, 循环结束.
24          */
25         for (int i = 1; i <= 5; i++) {       //i的值的变化: 1, 2, 3, 4, 5
26             //3. 将获取到的数字依次累加给变量sum
27             //sum = sum + i;
28             sum += i;
29         }
30         //4. 当循环结束后, sum记录的就是数字之和, 打印即可.
31         System.out.println(sum);
32     }
33 }

 1 package com.it.demo02_exercise;
 2
 3 /*
 4     案例: 获取到所有的水仙花数, 并将结果打印到控制台上.
 5
 6     水仙花数解释:
 7         1. 水仙花数肯定是一个3位数.
 8         2. 它的各个位数数字的立方和相加 等于 它本身, 例如:
 9             153就是一个水仙花数, 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3
10  */
11 public class ForDemo03 {
12     public static void main(String[] args) {
13         //方式一: 普通版.
14         /*//1. 通过for循环, 获取所有的三位数.
15         for (int i = 100; i < 1000; i++) {
16             //2. 获取该数字的各个位数的数字.
17             int ge = i / 1 % 10;
18             int shi = i / 10 % 10;
19             int bai = i / 100 % 10;
20             //3. 判读其是否是水仙花数.
21             if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
22                 //4. 如果是, 就打印.
23                 System.out.println(i);
24             }
25         }*/
26
27         //方式二: 优化版
28         //int ge = 0, shi = 0, bai = 0;
29         //1. 通过for循环, 获取所有的三位数.
30         for (int i = 100, ge = 0, shi = 0, bai = 0; i < 1000; i++) {
31             //2. 获取该数字的各个位数的数字.
32            ge = i / 1 % 10;
33            shi = i / 10 % 10;
34            bai = i / 100 % 10;
35             //3. 判读其是否是水仙花数.
36             if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
37                 //4. 如果是, 就打印.
38                 System.out.println(i);
39             }
40         }
41     }
42 }

 1 package com.it.demo02_exercise;
 2
 3 /*
 4     案例: 统计所有水仙花数的个数, 并将其打印到控制台上.        统计思想.
 5
 6       细节:
 7         1. 定义统计变量(学名: 计数器), 该变量必须定义到循环的外边.
 8         2. 在循环结束后, 统计变量记录的就是所有满足条件的 数据的 个数.
 9  */
10 public class ForDemo04 {
11     public static void main(String[] args) {
12         //1. 定义统计变量count, 用来当做计数器.
13         int count = 0;
14         //2. 通过for循环, 获取所有的三位数.
15         for (int i = 100, ge = 0, shi = 0, bai = 0; i < 1000; i++) {
16             //3. 获取该数字的各个位数的数字.
17             ge = i / 1 % 10;
18             shi = i / 10 % 10;
19             bai = i / 100 % 10;
20             //4. 判断其是否是水仙花数, 如果是, 则 统计变量要++
21             if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai) {
22                 count++;
23             }
24         }
25         //5. 当for循环结束后, 计数器记录的就是我们想要的值, 直接打印即可.
26         System.out.println("所有水仙花数的个数是: " + count);
27     }
28 }

 1 package demo04;
 2
 3 public class ForForDemo {
 4     public static void main(String[] args) {
 5         for (int i = 0; i <= 9; i++) {
 6             for (int j = 0; j <= i; j++) {
 7                 System.out.print("*");
 8             }
 9             System.out.println();
10         }
11     }
12 }

 1 package com.it.demo05_break_continue;
 2
 3 //案例: 演示continue的用法.
 4
 5 //continue:   用于结束本次循环, 进行下一次循环的, 循环还会继续执行.
 6 public class Demo02 {
 7     public static void main(String[] args) {
 8         //需求: 打印1~10之间, 所有不是3倍数的整数.
 9         for (int i = 1; i <= 10 ; i++) {
10             //判断当前数字是否是3的倍数, 如果是, 就跳过本次循环.
11             if (i % 3 == 0) {       //能进来的值有: 3, 6, 9
12                 //只要是3的倍数, 就不打印.
13                 continue;
14             }
15             System.out.println(i);
16         }
17     }
18 }

 1 package com.it.demo06_forfor;
 2
 3 /*
 4     案例: 打印矩形.
 5
 6     需求:
 7         1.在控制台打印一个3行5列的矩形星星序列, 具体格式如下:
 8          *****
 9          *****
10          *****
11         2.要求: 一次只能打印一个"*"
12  */
13 public class Demo02 {
14     public static void main(String[] args) {
15         //方式一: 输出语句直接打印. 不能这样写, 太Low了.
16         /*System.out.println("*****");
17         System.out.println("*****");
18         System.out.println("*****");*/
19
20         //方式二: 分解版.
21         /*//打印第一行
22         for (int j = 1; j <= 5; j++) {
23             System.out.print("*");
24         }
25         System.out.println();       //每行打印结束后, 记得加: 换行.
26
27         //打印第二行
28         for (int j = 1; j <= 5; j++) {
29             System.out.print("*");
30         }
31         System.out.println();
32
33         //打印第三行
34         for (int j = 1; j <= 5; j++) {
35             System.out.print("*");
36         }
37         System.out.println();       //每行打印结束后, 记得加: 换行.*/
38
39         //方式三: 循环嵌套版.
40         for (int i = 1; i <= 3 ; i++) {     //外循环, 控制行数.
41             for (int j = 1; j <= 5; j++) {  //内循环, 控制列数
42                 System.out.print("*");
43             }
44             System.out.println();       //每行打印结束后, 记得加: 换行.
45         }
46     }
47 }

 1 package com.it.demo06_forfor;
 2
 3 import javax.sound.midi.Soundbank;
 4
 5 /*
 6     案例: 循环嵌套之打印正三角形.
 7
 8     需求:
 9         1.在控制台打印一个5行5列的正三角形星星序列, 具体格式如下:
10             *
11             **
12             ***
13             ****
14             *****
15         2.要求: 一次只能打印一个"*"
16
17      结论(记忆):
18         打印正三角形和打印矩形相比, (内循环的)判断条件发生变化.
19  */
20 public class Demo03 {
21     public static void main(String[] args) {
22         //方式二: 合并版
23         for (int i = 1; i <= 5 ; i++) {         //外循环, 控制行数,    i的值的变化: 1, 2, 3, 4, 5
24             for (int j = 1; j <= i ; j++) {     //内循环, 控制列数     j的值的变化: 1, 2, 3, 4, 5
25                 System.out.print("*");
26             }
27             System.out.println();       //每行打印完毕后, 记得加换行.
28         }
29
30         //方式一: 分解版.
31         /*//打印第一行
32         for (int j = 1; j <= 1 ; j++) {
33             System.out.print("*");
34         }
35         System.out.println();       //每行打印完毕后, 记得加换行.
36
37         //打印第二行
38         for (int j = 1; j <= 2 ; j++) {
39             System.out.print("*");
40         }
41         System.out.println();       //每行打印完毕后, 记得加换行.
42
43         //打印第三行
44         for (int j = 1; j <= 3 ; j++) {
45             System.out.print("*");
46         }
47         System.out.println();       //每行打印完毕后, 记得加换行.
48
49         //打印第四行
50         for (int j = 1; j <= 4 ; j++) {
51             System.out.print("*");
52         }
53         System.out.println();       //每行打印完毕后, 记得加换行.
54
55         //打印第五行
56         for (int j = 1; j <= 5 ; j++) {
57             System.out.print("*");
58         }
59         System.out.println();       //每行打印完毕后, 记得加换行.*/
60
61     }
62 }

 1 package com.it.demo06_forfor;
 2
 3 /*
 4     案例: 循环嵌套之打印倒三角形.
 5
 6     需求:
 7         1.在控制台打印一个5行5列的正三角形星星序列, 具体格式如下:
 8             *****
 9             ****
10             ***
11             **
12             *
13         2.要求: 一次只能打印一个"*"
14
15      结论(记忆):
16         打印倒三角形和打印矩形相比, (内循环的)初始化条件发生变化.
17  */
18 public class Demo04 {
19     public static void main(String[] args) {
20         //方式二: 合并版
21         for (int i = 1; i <= 5 ; i++) {         //外循环, 控制行数,    i的值的变化: 1, 2, 3, 4, 5
22             for (int j = i; j <= 5 ; j++) {     //内循环, 控制列数     j的值的变化: 5, 4, 3, 2, 1
23                 System.out.print("*");
24             }
25             System.out.println();       //每行打印完毕后, 记得加换行.
26         }
27
28         //方式一: 分解版.
29       /*  //打印第一行
30         for (int j = 1; j <= 5 ; j++) {
31             System.out.print("*");
32         }
33         System.out.println();       //每行打印完毕后, 记得加换行.
34
35         //打印第二行
36         for (int j = 2; j <= 5 ; j++) {
37             System.out.print("*");
38         }
39         System.out.println();       //每行打印完毕后, 记得加换行.
40
41         //打印第三行
42         for (int j = 3; j <= 5 ; j++) {
43             System.out.print("*");
44         }
45         System.out.println();       //每行打印完毕后, 记得加换行.
46
47         //打印第四行
48         for (int j = 4; j <= 5 ; j++) {
49             System.out.print("*");
50         }
51         System.out.println();       //每行打印完毕后, 记得加换行.
52
53         //打印第五行
54         for (int j = 5; j <= 5 ; j++) {
55             System.out.print("*");
56         }
57         System.out.println();       //每行打印完毕后, 记得加换行.*/
58
59     }
60 }

 1 package com.it.demo06_forfor;
 2
 3 /*
 4     案例: 演示带标号的循环的结束.
 5
 6     思路:
 7         1. 给循环起个名字, 要符合命名规范.
 8         2. break 或者 continue的后边可以加上 循环的名字, 则它们就可以操作此循环了.
 9  */
10 public class Demo05 {
11     public static void main(String[] args) {
12         //需求: 打印2020年1月至2023年12月之间所有的月份, 格式为: XXXX年XX月
13         A: for (int i = 2020; i <= 2023 ; i++) {       //外循环, 控制年份.
14             B: for (int j = 1; j <= 12 ; j++) {        //内循环, 控制月份.
15                 System.out.print(i + "年"+ j +"月\t");
16                 break A;        //结束外循环
17                 //break B;        //结束内循环;
18                 //break;          //结束内循环;
19             }
20             System.out.println();       //记得加换行
21         }
22     }
23 }

 1 package com.it.demo06_forfor;
 2
 3 /*
 4     案例: 演示关于大括号能否省略的问题.
 5
 6     结论(记忆):
 7         1. 不管是if语句, 还是循环语句, 如果控制的语句体只有一行, 则大括号可以省略不写.
 8         2. 前提: 这行代码不能是定义变量的代码, 因为: 定义变量的代码, 在底层其实是两行, 如下;
 9             int a = 10; 在底层其实是: int a; a = 10;
10  */
11 public class Demo06 {
12     public static void main(String[] args) {
13         //演示: 不管是if语句, 还是循环语句, 如果控制的语句体只有一行, 则大括号可以省略不写.
14         /*if (5 > 3)
15             System.out.println("hello world!");
16         System.out.println("夯哥");*/
17
18         //演示: 前提: 这行代码不能是定义变量的代码,
19         /*if (5 > 3)
20             int b = 10;     //报错, 因为这行代码其实是两行代码, 具体如下: */
21
22         /*if (5 > 3) {
23             int a;
24         }
25         a = 10;*/
26
27         for (int i = 0; i < 10; i++)
28             System.out.println("hello world");
29             //int a = 10;           //报错
30     }
31 }

package com.it.demo02_exercise;

/*
    案例: 打印99乘法表.

    思路:
        1. 打印一个9行9列的 * 矩形.
        2. 将其演变为 正三角形的图形.
        3. 用 1 * 3 = 3 这样的格式来替代上述的 *
        4. 用指定值, 替代乘法表中对应的数字.
 */
public class ForForDemo06 {
    public static void main(String[] args) {
        //1. 打印一个9行9列的 * 矩形.
        /*for (int i = 1; i <= 9 ; i++) {         //外循环控制行数
            for (int j = 1; j <= 9 ; j++) {     //内循环控制列数
                System.out.print("*\t");          //每行具体打印的内容.
            }
            System.out.println();               //每打印完一行数据, 记得要换行.
        }*/

        //2. 将其演变为 正三角形的图形.
        /*for (int i = 1; i <= 9 ; i++) {         //外循环控制行数
            for (int j = 1; j <= i ; j++) {     //内循环控制列数
                System.out.print("*\t");          //每行具体打印的内容.
            }
            System.out.println();               //每打印完一行数据, 记得要换行.
        }*/

        //3. 用 1 * 3 = 3 这样的格式来替代上述的 *
        /*for (int i = 1; i <= 9 ; i++) {         //外循环控制行数
            for (int j = 1; j <= i ; j++) {     //内循环控制列数
                System.out.print("1 * 3 = 3\t");          //每行具体打印的内容.
            }
            System.out.println();               //每打印完一行数据, 记得要换行.
        }*/

        //4. 用指定值, 替代乘法表中对应的数字.
        for (int i = 1; i <= 9 ; i++) {         //外循环控制行数
            for (int j = 1; j <= i ; j++) {     //内循环控制列数
                System.out.print(j + " * " + i +" = "+ i * j +"\t");          //每行具体打印的内容.
            }
            System.out.println();               //每打印完一行数据, 记得要换行.
        }
    }
}

 1 package demo04;
 2
 3 public class DoWhileDemo {
 4     public static void main(String[] args) {
 5         int x = 1;
 6         do{
 7             System.out.println("x = "+x);
 8             x++;
 9         }while(x <= 4);
10     }
11 }

 1 package com.it.demo04_do_while;
 2
 3 /*
 4     案例: 演示do.while循环, 入门,  了解即可.
 5
 6     do.while循环简介:
 7         概述:
 8             它在实际开发中用的不多, 了解即可.
 9         格式:
10            初始化条件1;
11            do{
12                 循环体4;
13                 控制条件3;
14             } while(判断条件2);
15          执行流程:
16             第一次循环:   1, 4, 3, 2         //不管判断条件是否成立, 循环体都要执行一次.
17             重复循环:     4, 3, 2            //如果判断条件成立, 则循环继续执行.
18             最后一次循环: 2                  ///如果判断条件不成立, 则循环结束执行.
19  */
20 public class Demo01 {
21     public static void main(String[] args) {
22         //需求: 通过do.while循环, 在控制台打印10次Hello World!
23         int i = 1;
24         do{
25             System.out.println("Hello World! " + i);;
26             i++;
27         } while(i <= 10);
28     }
29 }

 1 package demo04;
 2
 3 public class ContinueDemo {
 4     public static void main(String[] args) {
 5         int sum = 0; // 定义变量sum，用于记住和
 6         for (int i = 1; i <= 100; i++) {
 7             if (i % 2 == 0) { // i是一个偶数，不累加
 8                 continue; // 结束本次循环
 9             }
10             sum += i; // 实现sum和i的累加
11         }
12         System.out.println("sum = " + sum);
13
14     }
15
16 }

 1 package com.it.demo05_break_continue;
 2
 3 //案例: 演示continue的用法.
 4
 5 //continue:   用于结束本次循环, 进行下一次循环的, 循环还会继续执行.
 6 public class Demo02 {
 7     public static void main(String[] args) {
 8         //需求: 打印1~10之间, 所有不是3倍数的整数.
 9         for (int i = 1; i <= 10 ; i++) {
10             //判断当前数字是否是3的倍数, 如果是, 就跳过本次循环.
11             if (i % 3 == 0) {       //能进来的值有: 3, 6, 9
12                 //只要是3的倍数, 就不打印.
13                 continue;
14             }
15             System.out.println(i);
16         }
17     }
18 }

 1 package demo04;
 2
 3 public class BreakDemo {
 4     public static void main(String[] args) {
 5         int x = 1;
 6         while(x <= 4){
 7             System.out.println("x = " + x );
 8             if(x == 3){
 9                 break;
10             }
11             x++;
12         }
13     }
14 }

 1 package demo04;
 2
 3 public class BreakDemo02 {
 4     public static void main(String[] args) {
 5         loop:for (int i = 0; i <= 9; i++) {
 6             for (int j = 0; j <= i; j++) {
 7                 if(i > 4){
 8                     break loop;
 9                 }
10                 System.out.println("*");
11             }
12             System.out.println("\n");
13         }
14     }
15
16 }

 1 package com.it.demo05_break_continue;
 2
 3 /*
 4     案例: 演示break入门.
 5
 6     循环控制跳转语句详解:
 7         概述:
 8             如果我们想参与到循环的具体执行流程, 例如: 提前结束循环, 或者结束某次循环等这些需求时, 都要用到循环控制跳转语句.
 9         分类:
10             break:      用于终止循环的, 循环不在继续执行.
11             continue:   用于结束本次循环, 进行下一次循环的, 循环还会继续执行.
12  */
13 public class Demo01 {
14     public static void main(String[] args) {
15         //需求: 打印10次HelloWorld, 当打印第五次的时候, 结束循环.
16         for (int i = 1; i <= 10; i++) {
17             if (i == 5) {
18                 //结束循环
19                 break;
20             }
21             System.out.println("Hello World! " + i);
22         }
23     }
24 }

---

 1 package com.it.demo01_ascii;
 2
 3 /*
 4     案例: 演示ASCII码表, 叫: 美国通用信息交换码表.
 5
 6     ASCII码表详解:
 7         它是用来描述 字符 及其 对应数字之间的关系的, 大白话理解:  就是哪个数字表示哪个字符.
 8
 9         为什么要有码表的概念呢?
10             因为计算机的底层存储, 操作和运算数据采用的是数据的二进制形式, 所以我们需要将字符转成对应的数字,
11             然后再由计算机来操作.
12
13         记住常用的3组对应关系:
14             'a'         97                  'b':98, 'c':99, 依次类推
15             'A'         65
16             '0'         48
17  */
18 public class Demo01 {
19     public static void main(String[] args) {
20         //需求: 观察代码, 并分析结果.
21         char ch = 'a';
22         int a = 1;
23         int b = ch + a;
24         System.out.println(b);      //98
25         System.out.println("----------------");
26         System.out.println('A' + 0);
27         System.out.println('0' + 0);
28     }
29 }

 1 package com.it.demo02_operator;
 2
 3 /*
 4     案例: 演示算术运算符.
 5
 6     运算符和表达式简介:
 7         运算符:
 8             就是用来连接变量或者常量的符号.
 9         表达式:
10             就是用运算符连接起来的式子, 用什么运算符连接, 就叫什么表达式,
11             例如: a + b, 叫: 算术表达式.
12
13     常用运算符主要有以下5类:
14         1. 算术运算符.
15             概述:
16                 顾名思义, 就是用来进行算术操作的.
17             分类:
18                 +, -, *, /, %, ++, --
19             注意事项:
20                 1. Java中整数相除, 结果肯定是整数, 要想获取小数, 则必须有浮点型数据参与运算.
21                 2. 关于+号的作用:
22                     针对于数字, 或者字符:   表示 加法 运算.
23                     针对于字符串:           表示 拼接.
24                         细节: 字符串数据和任意类型的值拼接, 结果都将是一个新的字符串.
25
26
27         2. 赋值运算符.
28         3. 关系运算符.
29         4. 逻辑运算符
30         5. 三元运算符.
31  */
32 public class Demo01 {
33     public static void main(String[] args) {
34         /*int a = 10, b = 3;
35         System.out.println(a + b);*/
36
37         //演示算术运算符
38         System.out.println(10 + 3);     //13
39         System.out.println(10 - 3);     //7
40         System.out.println(10 * 3);     //30
41         System.out.println(10 / 3);     //3
42         System.out.println(10 % 3);     //1
43         System.out.println("--------------------------");
44
45         //要想获取小数, 则必须有浮点型数据参与运算.
46         System.out.println(10 * 1.0 / 3);       //3.33333
47         System.out.println("--------------------------");
48
49         //关于+号的作用
50         //针对于数字
51         System.out.println(11 + 22);            //33
52         //针对于字符
53         System.out.println('a' + 'b');          //195
54         //针对于字符串
55         System.out.println("hello" + "world");  //helloworld
56         System.out.println("--------------------------");
57
58         //细节: 字符串数据和任意类型的值拼接, 结果都将是一个新的字符串.
59         System.out.println(true + "abc" + 123 + "cd");      //"trueabc123cd"
60
61         //java中的代码默认采用的是顺序结构, 即: 代码会按照从上往下, 从左往右的顺序依次逐行执行.
62         System.out.println(10 + 10 + "hello" + 10 + 10);    //20hello1010
63     }
64 }

 1 package com.it.demo02_operator;
 2
 3 /*
 4     案例: 演示自增和自减运算符.
 5
 6     涉及到的运算符如下:
 7         ++, --
 8
 9         它们的功能都是相似的, 只不过一个是加, 一个是减, 此处以 自增举例:
10             单独使用:
11                 前加后加没有任何的区别, 都是自身 + 1
12             参与运算:
13                 前加: 先自身+1, 然后以新值来参与运算.
14                 后加: 先以原值来参与运算, 再自身+1
15  */
16 public class Demo02 {
17     public static void main(String[] args) {
18         //需求: 演示自增和自减运算符, 此处我只以 自增运算符举例, 自减留给你自己测试.
19         //演示: 单独使用
20         int a = 10;
21         //a++;        //后加
22         ++a;          //前加
23         System.out.println(a);          //11
24         System.out.println("---------------------");
25
26
27         //演示: 参与运算:
28         int b = 5;
29         //参与运算之后加: 先以原值来参与运算, 再自身+1
30        /* int c = b++;
31         System.out.println(b);      //6
32         System.out.println(c);      //5*/
33
34        //参与运算之前加: 先自身+1, 然后以新值来参与运算.
35         int c = ++b;
36         System.out.println(b);      //6
37         System.out.println(c);      //6
38         System.out.println("---------------------");
39
40
41         //综合小案例
42         int aa = 3;
43         /*
44             aa =  4      5      4      3
45             bb =  3   +  5   +  4   -  4
46          */
47         int bb = aa++ + ++aa + --aa - aa--;
48         System.out.println(aa);         //3
49         System.out.println(bb);         //8
50     }
51 }

 1 package com.it.demo02_operator;
 2
 3 /*
 4     案例: 演示赋值运算符.
 5
 6     概述:
 7         顾名思义, 就是用来进行 赋值操作的.
 8
 9     分类:
10         基本的赋值运算符:   =
11         扩展的赋值运算符:   +=, -=, /=, *=, %=
12             它的功能是: 此处以 += 举例
13                 把左边的值和右边的值进行 加法 运算, 然后把最终结果赋值给左边.
14     注意事项:
15         1. 不要把 = 写成 ==, 否则结果可能不是你想要的.
16         2. 扩展的赋值运算符隐含包含有: 强制类型转换.
17         3. 赋值运算符的左边, 必须是变量.
18  */
19 public class Demo03 {
20     public static void main(String[] args) {
21         //演示 基本的赋值运算符
22         //把常量10 赋值给 int类型的变量 a
23         int a = 10;
24
25         //扩展的赋值运算符: 此处以 += 举例
26         int b = 5;
27        /* a += b;
28         System.out.println(a);      //15
29         System.out.println(b);      //5*/
30         System.out.println("---------------------");
31
32         //演示 赋值运算符的 注意事项
33         //1. 不要把 = 写成 ==, 否则结果可能不是你想要的.
34         System.out.println(a == b);         //=是赋值, ==是比较是否相等
35         System.out.println("---------------------");
36
37         //2. 扩展的赋值运算符隐含包含有: 强制类型转换.
38         byte b1 = 3;
39         //b1 = b1 + 4;        //因为b1是byte类型, byte和int运算结果也是int类型, 赋值给byte, 会报错
40         b1 += 4;              //不报错, 等价于:   b1 = (byte)(b1 + 4)
41         System.out.println(b1);     //7
42         System.out.println("---------------------");
43
44         //3. 赋值运算符的左边, 必须是变量.
45         //4 += b1;        //报错, 因为4是常量, 它的值是不能修改的.
46     }
47 }

 1 package com.it.demo02_operator;
 2
 3 /*
 4     案例: 演示 关系运算符.
 5
 6     概述:
 7         也叫比较运算符, 就是用来描述 变量和常量 之间关系的.
 8     分类:
 9         ==, !=, >, >=, <, <=
10      注意事项:
11         1. 关系表达式的最终结果一定是boolean类型的数据, 要么true, 要么是false.
12         2. 不要把 == 写成 =, 否则结果可能不是你想要的.
13  */
14 public class Demo04 {
15     //main方法作为程序的主入口, 所有的代码都是从这里开始执行的.
16     public static void main(String[] args) {
17         //1.定义两个int类型的变量a和b, 分别赋值为10和5.
18         int a = 10, b = 5;
19         //2.通过关系运算符比较这两个变量之间的关系, 并打印结果.
20         System.out.println(a == b);     //false
21         System.out.println(a != b);     //true
22         System.out.println(a > b);      //true
23         System.out.println(a >= b);     //true
24         System.out.println(a < b);      //false
25         System.out.println(a <= b);     //false
26         System.out.println("---------------------------");
27
28         //演示 关系运算符的注意事项.
29         System.out.println(5 >= 5);     //true
30         System.out.println(5 <= 5);     //true
31         System.out.println("---------------------------");
32
33         //演示 不要把 == 写成 =, 否则结果可能不是你想要的.
34         System.out.println(a = b);      //5
35     }
36 }

 1 package com.it.demo02_operator;
 2
 3 /*
 4     案例: 演示逻辑运算符的用法,  这个类演示的是: 基本的逻辑运算符.
 5
 6     概述:
 7         就是用来连接 关系表达式的符号, 这多个关系表达式要么都成立, 要么成立任意一个即可, 或者取反等操作.
 8     分类:
 9         &   逻辑与, 并且的意思, 要求所有条件都要满足, 即: 有false则整体为false.
10         |   逻辑或, 或者的意思, 要求满足其中任意一个条件即可, 即: 有true则整体为true.
11         !   逻辑非, 取反的意思, 以前是false, 现在是true, 以前是true, 现在是false.
12         ^   逻辑异或, 求异同的意思, 相同为false, 不同为true.
13  */
14 public class Demo05 {
15     public static void main(String[] args) {
16         //1.定义三个int类型的变量a, b, c, 它们的初始化值分别为10, 20, 30.
17         int a = 10, b = 20, c = 30;
18         //2.通过上述的三个变量, 演示各个逻辑运算符.
19         System.out.println(a + b > 15 & a + c < 30);   //true & false -> false
20         System.out.println("--------------------------------------");
21
22         //为了方便大家理解逻辑运算符的用法, 此处咱们来举个例子, 程德找女朋友的历程.
23         //因为程德学的是大数据, 未来发展形势巨好, 所以一开始他找女朋友要求比较高, 要求: 必须长得好看, 还得身材好.
24         System.out.println(true & true);        //true
25         System.out.println(false & true);       //false
26         System.out.println(true & false);       //false
27         System.out.println(false & false);      //false
28         System.out.println("--------------------------------------");
29
30         //后来发现, 现在社会适龄的女孩子比男孩子要少很多, 像上述要求的女朋友不好找, 于是 程德 就降低了要求: 只要长得好看或者身材好就行.
31         System.out.println(true | true);        //true
32         System.out.println(false | true);       //true
33         System.out.println(true | false);       //true
34         System.out.println(false | false);      //false
35         System.out.println("--------------------------------------");
36
37         //后来发现, 这样的女朋友还是不好找, 于是又降低了要求, 只要不是男的就行.
38         System.out.println(!true);          //false
39         System.out.println(!false);         //true
40         //细节: 对一个boolean值进行偶数次取反, 该值不变
41         System.out.println(!!!!!!false);         //false
42         System.out.println("--------------------------------------");
43
44         //后来发现, 这样的女朋友还是不好找, 于是最终还是找了个男的, 但是国家法律不承认.
45         System.out.println(true ^ true);        //false
46         System.out.println(false ^ true);       //true
47         System.out.println(true ^ false);       //true
48         System.out.println(false ^ false);      //false
49
50     }
51 }

 1 package com.it.demo02_operator;
 2
 3 /*
 4     案例: 演示短路逻辑运算符
 5
 6     概述:
 7         所谓的短路逻辑运算符意思是: 具有短路效应的逻辑运算符, 即前边的式子如果能决定整个式子的最终结果后, 则后边的式子不执行, 这样做可以节约资源, 提高效率.
 8     分类:
 9         短路与(双与):   &&
10             它的功能和逻辑与(单与, &)相似, 即: 有false则整体为false, 但是具有短路效应, 前边出现false, 后边不执行.
11         短路或(双或):   ||
12             它的功能和逻辑或(单或, |)相似, 即: 有true则整体为true, 但是具有短路效应, 前边出现true, 后边不执行.
13
14     总结:
15         常用的逻辑运算符有: &&, ||, !
16  */
17 public class Demo06 {
18     public static void main(String[] args) {
19         //需求: 演示短路与
20         //步骤1: 先演示逻辑与, 即: 它没有短路效应
21         int a = 2, b = 5;
22         /*System.out.println(a++ > 6 & b++ < 7);      //false & true -> false
23         System.out.println(a);          //3
24         System.out.println(b);          //6*/
25
26         //步骤2: 演示短路与, 即: 它有短路效应, 而且功能和 逻辑与 一样.
27         System.out.println(a++ > 6 && b++ < 7);      //false && ??   -> false
28         System.out.println(a);          //3
29         System.out.println(b);          //5
30
31         //需求: 演示短路或, 这个代码就留给你自己测试了.
32     }
33 }

package com.it.demo02_operator;

/*
    案例:  演示三元运算符入门案例.

    概述:
        三元运算符也叫三目运算符, 即它由3部分组成, 格式如下.
    格式:
        关系表达式 ? 表达式1 : 表达式2;
    执行流程:
        1. 先执行关系表达式, 看结果是true, 还是false.
        2. 如果是true, 则执行表达式1
        3. 如果是false, 则执行表达式2
 */
public class Demo07 {
    public static void main(String[] args) {
        //1.定义两个int类型的变量a. b, 初始化值分别为10, 20
        int a = 10, b = 20;
        //2.通过三元运算符, 获取变量a和b的最大值.
        /*
            下边这行代码的意思是:
                1. 先执行 a > b 这个判断(关系表达式), 看起结果是否成立.
                2. 如果成立, 就将变量a的值, 赋值给变量max
                3. 如果不成立, 就将变量b的值, 赋值给变量max

         */
        int max = a > b ? a : b;
        //3.将结果(最大值)打印到控制台上.
        System.out.println(max);
    }
}

 1 package com.it.demo03_exercise;
 2
 3 /*
 4     案例: 判断两只老虎的体重是否相同.
 5
 6     需求:
 7         动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。
 8  */
 9 public class Demo01 {
10     public static void main(String[] args) {
11         //1. 定义两个变量, 分别记录两只老虎的体重.
12         int width1 = 180;
13         int width2 = 200;
14
15         //2. 通过三元运算符判断两只老虎的体重是否相同, 并将结果赋值给变量.
16         //方式一: 通过三元实现
17         //boolean flag = width1 == width2 ? true : false;
18
19         //方式二: 直接比较
20         boolean flag = width1 == width2;
21
22         //3. 打印结果.
23         System.out.println(flag);
24     }
25 }

 1 package com.it.demo03_exercise;
 2
 3 /*
 4     案例: 获取三个和尚的最高身高, 即: 演示三元运算符的嵌套.
 5
 6     需求:
 7         1.一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm.
 8         2.请用程序实现获取这三个和尚的最高身高。
 9  */
10 public class Demo02 {
11     public static void main(String[] args) {
12         //1. 定义三个变量, 分别记录三个和尚的身高.
13         int height1 = 150, height2 = 210, height3 = 165;
14
15         //2. 获取三个和尚中的最高身高.
16         //方式一: 分解版, 要求必须能写出来.
17         /*//2.1 先获取前两个和尚的最高身高, 用临时变量 temp记录.
18         int temp = height1 > height2 ? height1 : height2;
19         //2.2 比较temp 和 第三个和尚的最高身高, 获取的值即为 三个和尚的最高身高.
20         int max = temp > height3 ? temp : height3;*/
21
22         //方式二: 合并版, 目前要求能看懂即可, 最好能写出来.
23         //公式:   (身高1 > 身高2) ?  (到这里, 说明身高1高, 比较身高1和身高3) : (到这里, 说明身高2高, 比较身高2和身高3)
24         //伪代码: (height1 > height2) ? height1大, 比较height1 和 height3 : height2大, 比较height2 和 height3;
25         int max = (height1 > height2) ? (height1 > height3 ? height1 : height3) : (height2 > height3 ? height2 : height3);
26
27         //如果是上述的代码出现在了实际开发中, 写法如下;
28         //int max2 = height1 > height2 ? height1 > height3 ? height1 : height3 : height2 > height3 ? height2 : height3;
29
30         //3. 打印结果.
31         System.out.println(max);
32         //System.out.println(max2);
33     }
34
35 }

package com.it.demo03_exercise;

/*
    案例: 键盘录入版_获取三个和尚的身高.

    考察: Scanner键盘录入, 三元运算符
 */

import java.util.Scanner;

public class Demo03 {
    public static void main(String[] args) {
        //细节: 只要创建一个键盘录入对象即可, 它里边的功能我们可以重复调用.
        Scanner sc = new Scanner(System.in);

        //1.提示用户录入第一个和尚的身高, 并接收
        System.out.println("请录入第1个和尚的身高: ");
        int height1 = sc.nextInt();
        //2.提示用户录入第二个和尚的身高, 并接收
        System.out.println("请录入第2个和尚的身高: ");
        int height2 = sc.nextInt();
        //3.提示用户录入第三个和尚的身高, 并接收.
        System.out.println("请录入第3个和尚的身高: ");
        int height3 = sc.nextInt();
        //4.通过三元运算符, 获取三个和尚中身高最矮的那个和尚的身高.
        //分解版: 自己写

        //合并版
        int max = (height1 > height2) ? (height1 > height3 ? height1 : height3) : (height2 > height3 ? height2 : height3);

        //5.将结果(最低身高)打印到控制台上.
        System.out.println("三个和尚的最高身高是: " + max);
    }
}

 1 package com.it.demo03_exercise;
 2
 3 import java.util.Scanner;
 4
 5 /*
 6     案例: 演示如何获取一个数字的各个位数的数字.
 7  */
 8 public class Demo04 {
 9     public static void main(String[] args) {
10         //1. 提示用户键盘录入一个三位数, 并接收.
11         //1.1 创建键盘录入对象.
12         Scanner sc = new Scanner(System.in);
13         //1.2 提示用户录入一个三位数.
14         System.out.println("请录入一个三位数: ");
15         //1.3 接收用户录入的数字.
16         int num = sc.nextInt();     //153
17         //2. 求这个数的个位,十位,百位分别是多少.
18         int ge = num / 1 % 10;
19         int shi = num / 10 % 10;
20         int bai = num / 100 % 10;
21         //3. 并将结果打印到控制台上.
22         System.out.println("ge: " + ge);
23         System.out.println("shi: " + shi);
24         System.out.println("bai: " + bai);
25     }
26 }

 1 package com.it.demo03_exercise;
 2
 3 import java.util.Scanner;
 4
 5 /*
 6     案例: 判断用户录入的整数是奇数还是偶数.
 7
 8     判断依据: 如果能和2整除 即为偶数, 否则为奇数.
 9  */
10 public class Demo05 {
11     public static void main(String[] args) {
12         //1.提示用户键盘录入一个数据并接收.
13         //1.1 创建键盘录入对象.
14         Scanner sc = new Scanner(System.in);
15         //1.2 提示用户录入一个整数.
16         System.out.println("请录入一个整数: ");
17         //1.3 接收用户录入的数据.
18         int num = sc.nextInt();
19
20         //2.判断该数据是奇数还是偶数, 并将结果打印到控制台上.
21         // 判断依据: 如果能和2整除 即为偶数, 否则为奇数.
22
23         //方式一: 通过if.else语句解决.
24         if (num % 2 == 0) {
25             //走这里, 说明能整除, 即: num是偶数.
26             System.out.println(num + "是偶数");
27         } else {
28             //走这里, 说明不能整除, 即: num是奇数.
29             System.out.println(num + "是奇数");
30         }
31         System.out.println("----------------------------");
32
33         //方式二: 用三元优化.
34         //细节: 能用三元运算符搞定的事儿, 一定都能用if.else语句搞定, 反之则不一定, 因为三元运算符的表达式不能是输出语句.
35         //num % 2 == 0 ? System.out.println(num + "是偶数") : System.out.println(num + "是奇数");     //报错, 因为三元运算符的表达式不能是输出语句
36
37         System.out.println(num + (num % 2 == 0 ? "是偶数" : "是奇数"));
38     }
39 }

 1 package com.it.demo03_exercise;
 2
 3 import java.util.Scanner;
 4
 5 /*
 6     案例: if语句案例之 发放奖励.
 7
 8     需求:
 9         1.小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
10         2.假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
11         3.礼物标准如下:
12             95~100 山地自行车一辆
13             90~94 游乐场玩一次
14             80~89 变形金刚玩具一个
15             80以下 胖揍一顿
16     细节: 测试数据的时候, 尽量要测试3类数据
17         1. 正确的值.
18         2. 边界值.
19         3. 非法值.
20  */
21 public class Demo06 {
22     public static void main(String[] args) {
23         //1. 创建键盘录入对象.
24         Scanner sc = new Scanner(System.in);
25         //2. 提示用户录入小明的考试成绩, 并接收.
26         System.out.println("请录入小明的考试成绩: ");
27         int score = sc.nextInt();
28
29         //3. 判断小明的考试成绩在哪个区间, 因为涉及到多个区间, 所以我们用if语句的多分支结构.
30         //方式一: 普通版
31         //95~100 山地自行车一辆
32         if (score >= 95 && score <= 100) {
33             System.out.println("奖励 山地自行车一辆");
34         } else if (score >= 90 && score < 95) {
35             //90~94 游乐场玩一次
36             System.out.println("奖励 游乐场玩一次");
37         } else if (score >= 80 && score < 90) {
38             //80~89 变形金刚玩具一个
39             System.out.println("奖励 变形金刚玩具一个");
40         } else if (score >= 0 && score < 80) {
41             //80以下 胖揍一顿
42             System.out.println("奖励 男女组合拳 + 扫帚棒法一套");
43         } else {
44             System.out.println("没有这样的成绩, 成绩无效!");
45         }
46         System.out.println("--------------------------------------------");
47
48         //方式二: 省略版, 即: 把if的"反条件", 即: else的条件 给用上.
49         if (score < 0 || score > 100) {
50             System.out.println("没有这样的成绩, 成绩无效!");
51         } else if(score >= 95){            //else的隐含条件:   score >= 0 && score <= 100
52             System.out.println("奖励 山地自行车一辆");
53         } else if(score >= 90){            //else的隐含条件:   score >= 0 && score < 95
54             System.out.println("奖励 游乐场玩一次");
55         } else if(score >= 80){            //else的隐含条件:   score >= 0 && score < 90
56             System.out.println("奖励 变形金刚玩具一个");
57         } else {                           //else的隐含条件:   score >= 0 && score < 80
58             System.out.println("奖励 男女组合拳 + 扫帚棒法一套");
59         }
60     }
61 }

 1 package com.it.demo03_exercise;
 2
 3 import java.util.Scanner;
 4
 5 /*
 6     案例: 演示获取3个整数的最大值.
 7  */
 8 public class Demo07 {
 9     public static void main(String[] args) {
10         //1.提示用户录入3个整数, 并接收.
11         Scanner sc = new Scanner(System.in);
12         System.out.println("请录入第1个整数: ");
13         int a = sc.nextInt();
14         System.out.println("请录入第2个整数: ");
15         int b = sc.nextInt();
16         System.out.println("请录入第3个整数: ");
17         int c = sc.nextInt();
18
19         //2.获取这三个整数的最大值.
20         //方式一: 通过if语句实现, 普通版.
21         int max = a;
22         if(a > b) {
23             //走这里, a 大
24             if (a > c) {
25                 max = a;
26             } else {
27                 max = c;
28             }
29         } else {
30             //走这里, b大
31             if (b > c) {
32                 max = b;
33             } else {
34                 max = c;
35             }
36         }
37
38         //方式二: 通过三元实现, 可以是分解版, 也可以是合并版.
39         int max2 = a > b ? a > c ? a : c : b > c ? b : c;
40
41
42         //方式三: 通过if语句实现, 升级版(无厘头版).
43         int max3 = a;
44         if (a > b && a > c) {           //要么a最大
45             max3 = a;
46         } else if(b > a && b > c) {     //要么b最大
47             max3 = b;
48         } else {                        //否则就是c最大.
49             max3 = c;
50         }
51
52
53         //3.将结果打印到控制台上.
54         System.out.println("最大值是: " + max);
55         System.out.println("最大值是: " + max2);
56         System.out.println("最大值是: " + max3);
57     }
58 }

 1 package com.it.demo03_exercise;
 2
 3 import java.util.Scanner;
 4
 5 /*
 6     案例: 根据考试成绩发放奖励.
 7
 8     需求:
 9         1.小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
10         2.假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
11         3.礼物标准如下:
12         –90~100 山地自行车一辆
13         –80~89 游乐场玩一次
14         –70~79 变形金刚玩具一个
15         –70以下 胖揍一顿
16  */
17 public class Demo08 {
18     public static void main(String[] args) {
19         //方案一: 采用if.else if语句实现,  自己写.
20
21         //方案二: 采用if语句 结合 switch语句实现.
22         //1. 创建键盘录入对象.
23         Scanner sc = new Scanner(System.in);
24         //2. 提示用户录入小明的考试成绩, 并接收.
25         System.out.println("请录入小明的考试成绩, 范围: 0 - 100分");
26         int score = sc.nextInt();
27
28         //3. 采用if判断, 用户录入的成绩是否合法.
29         if (score < 0 || score > 100) {
30             //4. 如果成绩不合法, 给出对应的提示.
31             System.out.println("您录入的考试成绩无效!");
32         } else {
33             //走到这里, 说明score是合法值, 即; score >= 0 && score <= 100
34             //5. 如果成绩合法, 用switch语句实现根据考试成绩, 发放对应的奖励.
35             switch (score / 10) {
36                 case 10:
37                 case 9:
38                     System.out.println("奖励 山地自行车一辆");
39                     break;
40                 case 8:
41                     System.out.println("奖励 游乐场玩一次");
42                     break;
43                 case 7:
44                     System.out.println("奖励 变形金刚玩具一个");
45                     break;
46                 default:
47                     System.out.println("奖励 胖揍一顿");
48                     break;
49             }
50         }
51
52
53     }
54 }

 1 package demo05;
 2
 3 import java.util.Random;
 4 import java.util.Scanner;
 5
 6 public class GuessNumber {
 7     public static void main(String[] args) {
 8         //1.通过Random类中方法nextInt（），生成一个1-100之间的随机数
 9         int randomNumber = new Random().nextInt(100);
10         System.out.println("随机数已生成！");
11         //2.输入猜的数字
12         System.out.println("----请输入您猜的数字：----");
13         Scanner sc = new Scanner(System.in);
14         int enterNumber = sc.nextInt();
15         //3.通过while循环，进行猜数字对错判断
16         //猜对，跳出循环，游戏结束
17         while(enterNumber != randomNumber){
18         //猜错了，根据结果，给出提示，接着猜数字，游戏继续
19         if(enterNumber>randomNumber) {
20         //如果猜大了，打印sorry，您猜大了!继续下一次循环
21         System.out.println("sorry，您猜大了!继续下一次循环");
22         }else {
23         //如果猜小了，打印sorry，您猜小了!继续下一次循环
24         System.out.println("sorry，您猜小了!继续下一次循环");
25         }
26         //输入猜的数字
27         System.out.println("----请输入您猜的数字：----");
28         enterNumber = sc.nextInt();
29         }
30         System.out.println("恭喜您，答对了！");
31
32     }
33 }

 1 package com.it.demo07_math;
 2
 3 /*
 4     案例: 演示Math入门.
 5
 6     Math简介:
 7         概述:
 8             就是用来获取随机数的, 获取的值的范围是 0.0 - 1.0之间, 包左不包右.
 9         格式:
10             double d = Math.random();           //获取一个 0.0 - 1.0之间的随机数, 包左不包右.
11
12         演化格式:       //获取1个 1-100 之间的随机数.
13  */
14 public class Demo01 {
15     public static void main(String[] args) {
16         //需求1: 获取一个 0.0 - 1.0之间的随机数, 包左不包右.
17        /* double d = Math.random();
18         System.out.println(d);*/
19
20        //需求2: 获取一个1-100之间的随机数, 包左不包右.
21         /*int num = (int)(Math.random() * 100) + 1;
22         System.out.println(num);*/
23
24
25         //需求3: 获取一个30-50之间的随机数, 包左不包右.
26         //思路: 30 - 50 -> 0 - 20, 然后获取的随机数 加上 30就可以了.
27         /*int num = (int)(Math.random() * 20) + 30;
28         System.out.println(num);*/
29
30
31
32         //需求: 使用Math类，生成5个1~10之间的随机整数, 并将结果打印到控制台.
33         for (int i = 1; i <= 5 ; i++) {
34             int num = (int)(Math.random() * 10) + 1;
35             System.out.println(num);
36         }
37
38     }
39 }