了解顺序结构的相关概述
掌握选择结构之if语句相关知识点
掌握选择结构之switch语句相关知识点

1. 流程控制

1.1 概述

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

例如: 某些代码是满足特定条件的情况下, 才会被执行. 而有些代码, 在满足某些条件的情况下, 需要重复执行, 这些, 都需要用到流程控制语句.

1.2 分类

顺序结构
选择结构(if语句, switch.case语句)
循环结构(for循环, while循环, do.while循环)

1.3 顺序结构

概述

顺序结构指的是代码是按照从上往下, 从左往右的顺序, 依次逐行执行的, 且顺序结构也是Java程序的默认结构.

图解

需求

定义类OrderDemo01, 在类中定义main方法, 打印如下数据:

//start
//HelloWorld1
//HelloWorld2
//HelloWorld3
//end

参考代码

public class OrderDemo01 {
    public static void main(String[] args) {
        //打印指定的数据
        System.out.println("start");
        System.out.println("HelloWorld1");
        System.out.println("HelloWorld2");
        System.out.println("HelloWorld13");
        System.out.println("end");
    }
}

2. 选择结构之if语句

2.1 概述

如果我们想某些代码是在满足条件的情况下, 才能被执行, 此时就需要用到选择结构了, 选择结构也叫分支结构, 主要分为以下两种:

if语句
switch.case语句

2.2 分类

if语句一般用于范围的判断, 例如: 如果当前时间是0~8点, 小黑就和你说: 早上好, 如果当前时间是9 ~12点, 小黑就和你说: 中午好. 根据应用场景的不同(即: 分支个数不同), if语句的格式主要分为以下三种:

if语句(也叫: 单分支)
if.else语句(也叫: 双分支)
if.else if语句(也叫: 多分支)

2.3 单分支

单分支结构一般用来判断一种情况, 格式如下:

格式

if(关系表达式) {
    //语句体;
}

执行流程

先执行关系表达式, 看其结果是true还是false.
如果是true, 则执行大括号中的语句体.
如果是false, 则大括号中的语句体不执行.

图解

需求

定义变量time表示时间, 如果它的范围是在[0,8]之间, 就打印早上好, 否则不操作.

解释: [0, 8], 意思是说 0~8之间, 包含0, 也包含8, 这种写法属于"前闭后闭".

[0, 8), 意思是: 0~8之间, 包含0, 不包含8, 这种写法属于"前闭后开", 也叫: 包左不包右.

参考代码

public class IfDemo01 {
    public static void main(String[] args) {
        int time = 5;
        if(time >= 0 && time <= 8) {
            System.out.println("早上好");
        }
    }
}

2.4 双分支

双分支结构指的是if. else语句, 一般用来判断两种情况, 格式如下:

2.4.1 格式

if(关系表达式) { //if的意思: 如果
    //语句体1;
} else {       //否则...
    //语句体2;
}

2.4.2 执行流程

先执行关系表达式, 看其结果是true还是false.
如果是true, 则执行语句体1.
如果是false, 则执行语句体2.

2.4.3 图解

2.4.5 案例一: if格式二入门

需求

定义变量time表示时间, 如果它的范围是在0~8之间, 就打印早上好, 否则就打印中午好.

参考代码

public class IfDemo02 {
    public static void main(String[] args) {
        int time = 5;
        if(time >= 0 && time <= 8) {
            System.out.println("早上好");
        } else {
            System.out.println("中午好");
        }
    }
}

2.4.6 案例二: 判断奇偶数

需求

提示用户键盘录入一个数据并接收.
判断该数据是奇数还是偶数, 并将结果打印到控制台上.

参考代码

public class IfDemo03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数: ");
        int num = sc.nextInt();
        if (num % 2 == 0) {
            System.out.println(num + "是偶数");
        } else {
            System.out.println(num + "是奇数");
        }
    }
}

记忆

if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写.

例如:

if(5 > 3)

System.out.println("夯哥最纯洁!");
if语句控制的语句体如果只有一行代码, 则该大括号可以省略不写, 定义变量的语法除外.

例如:

if(5 > 3)

int a = 10; //这样写会报错, jvm会识别这样代码为两行: int a; a = 10;

上述的代码就相当于:

if(5 > 3) {

int a;

}

a = 10; //这样写肯定会报错.
你省略if后边的大括号时, 有个问题一定要注意, 不要乱写分号.

例如:

if(5 > 3) ; //这里如果写分号了, 就意味着if语句结束了.

System.out.println("本意: 这行代码只有条件成立才会被执行");

2.5 多分支

多分支结构指的是if. else if语句, 一般用来判断多种情况, 格式如下:

2.5.1 格式

if(关系表达式1) {
    //语句体1;
} else if(关系表达式2){
    //语句体2;
} else if(关系表达式3){  //这里可以根据需求, 有多个else if语句
    //语句体3;
} else {
    //语句体n;
}

2.4.2 执行流程

先执行关系表达式1, 看其结果是true还是false.
如果是true, 则执行语句体1, 整个if语句结束.
如果是false, 则判断关系表达式2, 看其结果是true还是false.
如果是true, 则执行语句体2, 整个if语句结束.
如果是false, 则判断关系表达式3, ...以此类推.
如果所有的关系表达式都不成立, 则执行else语句的语句体n, 整个if语句结束.

2.4.3 图解

2.4.4 案例一: 打印星期

需求

提示用户录入[1, 7]之间的数字, 并接收.
根据用户录入的数字, 打印对应的星期, 格式如下:
- 用户录入1, 打印"星期一"
- 用户录入2, 打印"星期二"
- ...以此类推
- 用户录入非法数字, 打印"没有这样的日期"

参考代码

import java.util.Scanner;

public class IfDemo04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个1 - 7之间的整数: ");
        int week = sc.nextInt();
        if (week == 1) {
        } else if(week == 2) {
            System.out.println("星期二");
        } else if(week == 3) {
            System.out.println("星期三");
        } else if(week == 4) {
            System.out.println("星期四");
        } else if(week == 5) {
            System.out.println("星期五");
        } else if(week == 6) {
            System.out.println("星期六");
        } else if(week == 7) {
            System.out.println("星期日");
        } else {
            System.out.println("没有这样的日期, 你是从火星来的吧!");
        }
    }
}

2.4.5 案例二: 发放奖励

需求

小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
礼物标准如下:
- 95~100 山地自行车一辆
- 90~94 游乐场玩一次
- 80~89 变形金刚玩具一个
- 80以下胖揍一顿

参考代码

import java.util.Scanner;

public class IfDemo05 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入小明的考试成绩: ");
        int score = sc.nextInt();
        if (score >= 95 && score <= 100) {
            System.out.println("奖励小明: 山地自行车一辆");
        } else if(score >= 90 && score < 95) {
            System.out.println("奖励小明: 游乐场玩儿一次");
        } else if(score >= 80 && score < 90) {
            System.out.println("奖励小明: 变形金刚玩具一个");
        } else if(score >= 0 && score < 80){
            System.out.println("奖励小明: 男女双混组合拳 + 扫帚棒法");
        } else {
            System.out.println("考试成绩录入有误.");
        }
    }
}

2.4.6 案例三: 获取最大值

需求

提示用户录入3个整数, 并接收.
通过if语句获取这三个整数的最大值.
将结果打印到控制台上.

参考代码

import java.util.Scanner;

public class IfDemo06 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入第一个整数: ");
        int a = sc.nextInt();
        System.out.println("请录入第二个整数: ");
        int b = sc.nextInt();
        System.out.println("请录入第三个整数: ");
        int c = sc.nextInt();

        //方式一: if嵌套实现.
        int max = a;
        int max2 = a;
        if (a > b) {
            if (a > c) {
                max = a;
            } else {
                max = c;
            }
        } else {
            if(b > c) {
                max = b;
            } else {
                max = c;
            }
        }
        System.out.println("最大值: " + max);
        //方式二: if. else.if语句实现
        if (a > b && a > c) {
            max2 = a;
        } else if(b > a && b > c) {
            max2 = b;
        } else {
            max2 = c;
        }
        System.out.println("最大值: " + max2);
    }
}

3. 选择结构之switch语句

3.1 概述

switch语句, 一般是用于做固定值判断的, 在实际开发中, 用到的频率也非常高, 所以也是要求大家掌握的知识点.

3.2 格式

switch(表达式) {
    case 值1:    
        语句体1;
        break;
    case 值2:
        语句体2;
        break;
    case 值3:
        语句体3;
        break;
    ...    //根据需求, 可以写多组case.
    default:    
        语句体n;
        break;
}

3.4 格式详解

1582129149773.png

3.5 执行流程

先计算表达式的值, 然后按照从上往下的顺序依次和每一个case对应的值相匹配.
如果能匹配成功, 则执行该case对应的语句体, 然后执行break, 至此, 整个switch语句结束.
如果和所有的case值都不匹配, 则执行default对应的语句体, 然后执行break, 至此, 整个switch语句结束.

解释: default语句就类似于if. else语句中的else, 当所有条件都不满足时才会执行.

3.6 执行流程图解

1582129267435.png

3.7 示例一: 春夏秋冬

需求

一年有12个月, 分属于春夏秋冬4个季节, 键盘录入一个月份, 请用程序实现判断该月份属于哪个季节, 并输出。
具体标准如下:
- 输入： 1、2、12 输出：冬季
- 输入： 3、4、5 输出：春季
- 输入： 6、7、8 输出：夏季
- 输入： 9、10、11 输出：秋季
- 输入：其它数字输出：数字有误

参考代码

import java.util.Scanner;

public class SwitchDemo07 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个月份: ");
        int month = sc.nextInt();
        switch (month) {
            case 12:
                System.out.println("冬季");
                break;
            case 1:
                System.out.println("冬季");
                break;
            case 2:
                System.out.println("冬季");
                break;
            case 3:
                System.out.println("春季");
                break;
            case 4:
                System.out.println("春季");
                break;
            case 5:
                System.out.println("春季");
                break;
            case 6:
                System.out.println("夏季");
                break;
            case 7:
                System.out.println("夏季");
                break;
            case 8:
                System.out.println("夏季");
                break;
            case 9:
                System.out.println("秋季");
                break;
            case 10:
                System.out.println("秋季");
                break;
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("没有这样的日期");
                break;
        }
    }
}

3.8 case穿透

概述

在switch语句中，如果case的后面不写break，将出现case穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。

格式

switch(表达式) {
    case 值1:    
        语句体1;   //假设表达式的值 = 值1, 则执行完语句体1后, 不会判断第二个case, 直接执行语句体2;
        break;
    case 值2:
        语句体2;
        break;
    case 值3:
        语句体3;
        break;
    ...    //根据需求, 可以写多组case.
    default:    
        语句体n;
        break;
}

需求
通过case穿透, 优化刚才的春夏秋冬案例.

参考代码

import java.util.Scanner;

public class SwitchDemo08 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个月份: ");
        int month = sc.nextInt();
        switch (month) {
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                System.out.println("没有这样的日期");
                break;
        }
    }
}

3.9 思考题

switch语句的小括号中, 可以放什么?
default语句必须放到switch语句的最后吗?
break关键字可以省略吗? 对执行结果是否有影响?

3.10 案例二: 发放奖励

需求

小明快要期末考试了，小明爸爸对他说，会根据他的考试成绩，送他不同的礼物.
假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
礼物标准如下:
- 90~100 山地自行车一辆
- 80~89 游乐场玩一次
- 70~79 变形金刚玩具一个
- 70以下胖揍一顿

参考代码

import java.util.Scanner;

public class SwitchDemo09 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入小明的考试成绩: ");
        int score = sc.nextInt();
        if (score >= 0 && score <= 100) {
            //合法成绩
            switch (score / 10) {
                case 10:
                case 9:
                    System.out.println("奖励小明: 山地自行车一辆");
                    break;
                case 8:
                    System.out.println("奖励小明: 游乐场玩儿一次");
                    break;
                case 7:
                    System.out.println("奖励小明: 变形金刚玩具一个");
                    break;
                default:
                    System.out.println("奖励小明: 男女双混组合拳 + 扫帚棒法");
                    break;
            }
        } else {
            //非法成绩
            System.out.println("您录入的成绩有误!");
        }
    }
}

4 练习题

4.1 案例一: 涨工资.

需求

根据工龄(整数)给员工涨工资(整数), 工龄和基本工资通过键盘录入
涨工资的条件如下：
- [10-15) +5000
- [5-10) +2500
- [3~5) +1000
- [1~3) +500
- [0~1) +200
打印格式如下:

您目前工作了10年，基本工资为 3000元, 应涨工资 5000元,涨后工资 8000元

参考代码

public static void main(String[] args) {
    // 1.创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        // 2.定义变量age表示工龄（假设为int类型），定义变量salary表示基本工资（假设为int类型）
//      int age,salary;
        // 3.通过键盘录入给工龄age赋值和基本工资salary赋值
//      age = sc.nextInt();
//      salary = sc.nextInt();
        int age = sc.nextInt();
        int salary = sc.nextInt();
        int addSalary = 0;
        // 4.对工龄进行逻辑判断，根据不同的工龄区间，进行涨工资salary+=n；（n表示：涨工资的数量）
        if(age>=15||age<0) {
            System.out.println("您输入的工龄不合法~");
            return ;
        }
        //[10-15)     +5000
        if(age>=10&&age<15) {
            addSalary = 5000;
        } else if(age>=5&&age<10){//[5-10)      +2500
            addSalary = 2500;
        } else if(age>=3&&age<5) {//[3~5)       +1000
            addSalary = 1000;
        } else if(age>=1&&age<3) {//[1~3)       +500
            addSalary = 500;
        } else if(age>=0&&age<1) {//[0~1)       +200
            addSalary = 200;
        }               
        // 5.按照格式进行打印
        System.out.println("您目前工作了"+age+"年，基本工资为 "+salary+"元, 应涨工资 "+addSalary+"元,涨后工资 "+(salary+addSalary)+"元");
}

4.2 案例二: 定义计算器

需求:

1.功能描述：模拟计算器功能，对键盘录入的两个int类型的数据进行加、减、乘、除的运算，并打印运算结果

2.要求：

(1)键盘录入三个整数,其中前两个整数代表参加运算的数据，

  第三个整数为要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算)

(2)使用今天所学知识完成功能

(3)演示格式如下:

  请输入第一个整数:30

  请输入第二个整数:40

  请输入您要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算):0

  控制台输出:30+40=70

实现步骤:
代码:

public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数据");
        int a = sc.nextInt();
        System.out.println("请输入第二个数据");
        int b = sc.nextInt();
        System.out.println("请输入您要进行的运算(0:表示加法运算,1:表示减法运算,2:表示乘法运算,3:表示除法运算):");
        int type = sc.nextInt();
        //定义变量用于接收结果
        double result = 0;
        switch(type) {
            case 0://做加法
                result = a + b;
                System.out.println(a+"+"+b+"="+result);
                break;
            case 1:
                result = a - b;
                System.out.println(a+"-"+b+"="+result);
                break;
            case 2:
                result = a * b;
                System.out.println(a+"*"+b+"="+result);
                break;
            case 3:
                result = a / (b + 0.0);
                System.out.println(a+"/"+b+"="+result);
                break;
            default:
                System.out.println("您输入有误");
        }
    }

4.3 案例三: 水仙花数

需求:

键盘录入一个三位数字,输出该三位数字是否是水仙花数字?

水仙花数字要求: 指的是一个三位数，个位、十位、百位的数字立方和等于原数

例如 153 3*3*3 + 5*5*5 + 1*1*1 = 27 + 125 + 1 = 153
实现步骤:

1.创建键盘录入对象

2.获取一个int数字

3.获取个位,十位,百位

4.求个位,十位,百位的立方和

5.利用if语句判断立方和是否等于该数字本身,并输出结果
代码实现:

public static void main(String[] args) {
    //1.创建键盘录入对象
    Scanner sc = new Scanner(System.in);
    //2.获取一个int数字
    System.out.println("请输入一个三位整数");
    int num = sc.nextInt();
        
    //3.获取个位,十位,百位
    int ge = num%10;
    int shi = num/10%10;
    int bai = num/100%10;
    //4.求个位,十位,百位的立方和
    int sum = ge*ge*ge + shi*shi*shi + bai*bai*bai;
        
    //5.利用if语句判断立方和是否等于该数字本身,并输出结果
    if(sum == num) {
        System.out.println(num+"是水仙花数字 ");
    } else {
        System.out.println(num+"不是水仙花数字 ");
    }
}

今日目标

掌握运算符的用法
掌握键盘录入功能
独立完成IDEA的安装和配置
掌握纸牌案例

1. 关系运算符

1.1 概述

关系运算符就是用来描述两个变量或者常量之间的关系的.主要分为以下6种:

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<	a
<=	a<=b，判断a是否小于等于b，成立为true，不成立为false

1.2 注意事项

关系运算符的结果都是boolean类型，要么是true，要么是false。
千万不要把==写成了=, 否则结果可能不是你想要的.

1.3 案例

需求

定义两个int类型的变量a和b, 分别赋值为10和5.
通过关系运算符比较这两个变量之间的关系, 并打印结果.

参考代码

public class OperatorDemo01 {
    public static void main(String[] args) {
        //定义两个int类型的变量a和b, 分别赋值为10和5.
        int a = 10;
        int b = 5;
        //通过`关系运算符`比较这两个变量之间的关系, 并打印结果.
        System.out.println(a > b);
        System.out.println(5 >= 5);
        System.out.println(a < b);
        System.out.println(5 <= 5);
        System.out.println(a != b);
        System.out.println(a == b);
        System.out.println(a = b);
        
        //关系运算符的最终结果是boolean类型, 所以我们也可以用boolean类型的变量接收.
        boolean flag = 10 < 5;
        System.out.println(flag);
    }
}

2. 逻辑运算符

2.1 概述

逻辑运算符是用来判断并且, 或者, 除非等逻辑关系的符号.
该符号两端一般连接值为布尔类型的关系表达式

例如: 某企业招工, 要求年龄必须在 20 ~ 65岁之间.

2.2 分类

注意: 假设下表中的a和b, 都是boolean类型的值.

符号	作用	说明
&	逻辑与	a&b，并且的意思. 有false则整体为false, 都为true, 则整体为true.
\|	逻辑或	a\|b，或者的意思, 有true则整体为true, 都为false, 则整体为false.
!	逻辑非	!a，取反的意思, 以前为true, 取反后为false, 以前为false, 取反后为true.
^	逻辑异或	a^b，异同的意思, 相同为false, 不同为true.

小技巧:

对一个布尔数据, 偶数次取反, 该数据值不变.

!true = false

2.3 示例: 逻辑运算符入门

需求

定义三个int类型的变量a, b, c, 它们的初始化值分别为10, 20, 30.
通过上述的三个变量, 演示各个逻辑运算符.

参考代码

public class OperatorDemo02 {
    public static void main(String[] args) {
        int a = 10, b = 20, c = 30;
        //&: 逻辑与, 并且的意思, 有false则整体为false.
        //相当于: 班长找女朋友, 要求长得漂亮, 并且身材好.
        System.out.println((a > b) & (a > c)); //false & false
        System.out.println((a < b) & (a > c)); //true & false
        System.out.println((a > b) & (a < c)); //false & true
        System.out.println((a < b) & (a < c)); //true & true
        System.out.println("-----------------");

        //|: 逻辑或, 或者的意思, 有true则整体为true.
        //相当于: 降低条件了, 要么长得漂亮, 要么身材好.
        System.out.println((a > b) | (a > c)); //false | false
        System.out.println((a < b) | (a > c)); //true | false
        System.out.println((a > b) | (a < c)); //false | true
        System.out.println((a < b) | (a < c)); //true | true
        System.out.println("-----------------");

        //!: 逻辑非, 取反的意思
        //相当于: 只要不是男的就行.
        System.out.println(!(a > b));   //!false
        System.out.println(!(a < b));   //!true
        System.out.println("-----------------");

        //逻辑异或, 异同的意思, 相同为false, 不同为true.
        //相当于: 最后还是找了个男的, 但是领不了证.
        //法律规定: 一夫一妻, 一男一女, 必须是异性才能领证.
        System.out.println((a > b) ^ (a > c)); //false ^ false
        System.out.println((a < b) ^ (a > c)); //true ^ false
        System.out.println((a > b) ^ (a < c)); //false ^ true
        System.out.println((a < b) ^ (a < c)); //true ^ true
    }
}

2.4 短路逻辑运算符

在实际开发中, 并且, 或者这样的操作是非常多的, 但是上述的&(逻辑与), !(逻辑或)运算符没有短路效应, 所以效率相对较低, 针对这种情况, 我们可以使用&&(短路与), ||(短路或)来优化.

2.4.1 格式

符号	作用	说明
&&	短路与	作用和&相同，但是有短路效果, 前边出现false, 后边不执行.
\|\|	短路或	作用和\|相同，但是有短路效果, 前边出现true, 后边不执行.

2.4.2 解释

在短路与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，短路与运算符就有这样的效果，可以提高效率。
同理在短路或运算中，一旦发现值为true，右边的表达式将不再参与运算。

2.4.3 短路和非短路之间的区别

逻辑与和短路与之间的区别
- 逻辑与&(也叫单与): 无论左边真假，右边都要执行。
- 短路与&&(也叫双与): 如果左边为真，右边执行；如果左边为假，右边不执行。
逻辑或和短路或之间的区别
- 逻辑或|(也叫单或): 无论左边真假，右边都要执行。
- 短路或||(也叫双或): 如果左边为假，右边执行；如果左边为真，右边不执行。
记忆: 在实际开发中, 我们用的最多的逻辑运算符就是: &&, ||, !

2.4.4 案例

需求

参考代码

public class OperatorDemo03 {
    public static void main(String[] args) {
        //1. 定义两个int类型的变量a和b, 初始化值分别为: 2, 5
        int a = 2, b = 5;
        //2. 演示逻辑与(&)
       /* System.out.println((a++ > 2) & (b++ < 7)); //两个表达式都会执行.
        System.out.println(a);
        System.out.println(b);*/
        System.out.println("------------------");

        //3. 演示短路与(&&)
        System.out.println((a++ > 2) && (b++ < 7)); //左边表达式结果为false, 右边不执行.
        System.out.println(a);
        System.out.println(b);
    }
}

3. 三元运算符

3.1 格式

三元运算符也叫三目运算符，即由三部分组成，格式如下：

(关系表达式) ? 表达式1：表达式2；

3.2 执行流程

先执行关系表达式, 看其结果是true还是false.
如果是true, 则执行表达式1
如果是false, 则执行表达式2

3.3 案例一: 入门案例

需求

定义两个int类型的变量a. b, 初始化值分别为10, 20
通过三元运算符, 获取变量a和b的最大值.
将结果(最大值)打印到控制台上.

参考代码

public class OperatorDemo04 {
    public static void main(String[] args) {
        //1. 定义两个int类型的变量a. b, 初始化值分别为10, 20
        int a = 10, b = 20;
        //2. 通过三元运算符, 获取变量a和b的最大值.
        int max = a < b ? b : a;
        //3. 将结果(最大值)打印到控制台上.
        System.out.println(max);
    }
}

3.4 案例二: 判断老虎体重

需求

动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，请用程序实现判断两只老虎的体重是否相同。

参考代码

public class OperatorDemo05 {
    public static void main(String[] args) {
        //1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
        int weight1 = 180;
        int weight2 = 200;
        //2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
        boolean flag = weight1 == weight2 ? true : false;
        //3：输出结果
        System.out.println("flag:" + flag);
    }
}

3.5 案例三: 获取和尚的最高身高

需求

一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm.
请用程序实现获取这三个和尚的最高身高。

参考代码

public class OperatorDemo06 {
    public static void main(String[] args) {
        //1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
        int h1 = 150;
        int h2 = 210;
        int h3 = 165;
        //2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int temp = h1 > h2 ? h1 : h2;
        //3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int max = temp > h3 ? temp : h3;
        //4：输出结果
        System.out.println("这三个和尚中身高最高的是：" + max +"cm");
    }
}

4. 键盘录入

4.1 概述

之前我们涉及到的数据都是写死的, 固定的数据, 这样做用户体验并不好, 我们就想着, 能不能让用户录入数据, 我们通过特定的代码来接收, 这样做就非常好玩儿了, 针对于这种情况, 我们可以通过键盘录入来实现.

即: Java中键盘录入功能指的就是Scanner类, 我们可以通过它的一些方法, 来获取用户录入的数据.

4.2 使用步骤

导包. 包就是文件夹.
注意:
- Scanner类是java.util包下的类, 使用之前必须要先导包.
- 导包的语句是定义在类的上面的, 格式如下:
```
import java.util.Scanner;
```

创建Scanner类的对象, 格式为:

//暂时先理解为固定格式, 也就是必须这么写.
Scanner sc = new Scanner(System.in);

通过Scanner类的nextInt()方法接收用户录入的数据.
```
int a = sc.nextInt();
```

4.3 案例一: Scanner入门

需求

提示用户录入他/她的年龄.
通过键盘录入功能, 接收用户录入的年龄.
将用户录入的数据(年龄)打印到控制台上.

参考代码

//导包
import java.util.Scanner;

public class ScannerDemo01 {
    public static void main(String[] args) {
        //1. 提示用户录入他/她的年龄.
        System.out.println("请录入您的年龄: ");
        //2. 通过键盘录入功能, 接收用户录入的年龄.
        Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
        //3. 将用户录入的数据(年龄)打印到控制台上.
        System.out.println("age: " + age);
    }
}

4.4 案例二: 键盘录入版和尚身高

需求

提示用户录入第一个和尚的身高, 并接收
提示用户录入第二个和尚的身高, 并接收
提示用户录入第三个和尚的身高, 并接收.
通过三元运算符, 获取三个和尚中身高最矮的那个和尚的身高.
将结果(最低身高)打印到控制台上.

参考代码

import java.util.Scanner;

public class ScannerDemo02 {
    public static void main(String[] args) {
        //身高未知，采用键盘录入实现。首先导包，然后创建对象。
        Scanner sc = new Scanner(System.in);
        //键盘录入三个身高分别赋值给三个变量。
        System.out.println("请输入第一个和尚的身高：");
        int h1 = sc.nextInt();
        System.out.println("请输入第二个和尚的身高：");
        int h2 = sc.nextInt();
        System.out.println("请输入第三个和尚的身高：");
        int h3 = sc.nextInt();
        //用三元运算符获取前两个和尚的较低身高值，并用临时身高变量保存起来。
        int temp = h1 < h2 ? h1 : h2;
        //用三元运算符获取临时身高值和第三个和尚身高较低值，并用最低身高变量保存。
        int min = temp < h3 ? temp : h3;
        //输出结果。
        System.out.println("这三个和尚中身高最低的是：" + min +"cm");
    }
}

IDEA常用快捷键

快捷键	功能
`Alt+Enter`	导入包，自动修正代码
`Ctrl+Y`	删除光标所在行
`Ctrl+D`	复制光标所在行的内容，插入光标位置下面
`Ctrl+Alt+L`	格式化代码
`Ctrl+/`	单行注释
`Ctrl+Shift+/`	选中代码注释，多行注释，再按取消注释
`Alt+Shift+上下箭头`	移动当前代码行

4.1 练习1

需求:

    小明左、右手中分别拿两张纸牌（比如：黑桃10和红桃8，数字10和8可通过键盘录入），要求编写代码交换小明手中的牌

运行效果:

请输入小明左手中的纸牌：10
请输入小明右手中的纸牌：8

互换前小明手中的纸牌：
左手中的纸牌：10
右手中的纸牌：8

互换后小明手中的纸牌：
左手中的纸牌：8
右手中的纸牌：10
实现步骤:

1.创建键盘录入对象
2.定义int类型的变量left和right，并通过nextInt()方法给left和right赋值
3.定义临时变量temp实现left和right变量值得交换
4.按格式打印交换后的结果

代码实现:

public class Task01 {
    public static void main(String[] args) {        
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //录入左手中的纸牌数字
        System.out.print("请输入小明左手中的纸牌：");
        int left = sc.nextInt();
        //录入右手中的纸牌数字
        System.out.print("请输入小明右手中的纸牌：");
        int right = sc.nextInt();
        //打印互换前的纸牌
        System.out.println();
        System.out.println("互换前小明手中的纸牌：");
        System.out.println("左手中的纸牌："+left);
        System.out.println("右手中的纸牌："+right);
        System.out.println();
        // 定义一个临时变量temp,保存left的值
        int temp = left;
        // 将right的值赋值给left
        left = right;
        // 将临时变量temp的值赋值给right 
        right = temp;
        // 打印交换后纸牌
        System.out.println("互换后小明手中的纸牌：");
        System.out.println("左手中的纸牌："+left);
        System.out.println("右手中的纸牌："+right);
    }
}

4.2 练习2

需求:

    定义一个int类型的变量,初始化值为123,求这个数的个位,十位,百位分别是多少?

运行效果:

123的个位是3,十位是2,百位是1

实现步骤:

1.定义一个变量，值为123
2.获取该数字中个位、十位、百位的数字
3.打印结果

代码实现:

public class Task02 {
    public static void main(String[] args) {
        //1.定义一个变量，值为123
        int n = 123;
        //2.获取该数字中个位、十位、百位的数字
        // 个位： 数字 % 10
        int ge = n % 10;
        // 十位： 数字 / 10 % 10;
        int shi = n / 10 % 10;
        // 百位： 数字 / 100 % 10;
        int bai = n /100 % 10;
        //3.打印结果
        //123的个位是3,十位是2,百位是1
        System.out.println(n + "的个位是"+ ge +",十位是"+ shi +",百位是" + bai);
    }
}

4.3 练习3

需求:

键盘录入一个三位数字,输出该三位数字是否是水仙花数字?

水仙花数字要求: 指的是一个三位数，个位、十位、百位的数字立方和等于原数

例如 `153 3*3*3 + 5*5*5 + 1*1*1 = 27 + 125 + 1 = 153`

运行效果:

153是水仙花数字吗? true

实现步骤:

1.创建键盘录入对象
2.获取一个int数字
3.获取个位,十位,百位
4.求个位,十位,百位的立方和
5.利用三元运算符求立方和是否等于该数字本身
6.打印结果

代码实现:

public class Task03 {
    public static void main(String[] args) {
        //1.创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        //2.获取一个int数字
        System.out.println("请输入一个三位整数");
        int num = sc.nextInt();
        
        //3.获取个位,十位,百位
        int ge = num%10;
        int shi = num/10%10;
        int bai = num/100%10;
        //4.求个位,十位,百位的立方和
        int sum = ge*ge*ge + shi*shi*shi + bai*bai*bai;
        
        //5.利用三元运算符求立方和是否等于该数字本身
        boolean flag = (sum==num)?true:false;
        
        //6.打印结果
        System.out.println(num+"是水仙花数字吗? "+flag);
    }
}

循环

理解循环的概述和分类
掌握for循环的用法
掌握while循环的用法
了解do.while循环的用法

1. 循环结构

1.1 概述

循环，即事物周而复始的变化。循环结构指的是，使一部分代码按照次数或一定的条件反复执行的一种代码结构. 有些时候, 我们想代码是在满足某些条件的情况下, 重复(循环)执行的, 就需要用到循环结构了.

例如: 打印100次HelloWorld. 如果不用循环实现的话, 输出语句我们就需要写100次, 我们发现这样做是非常繁琐的. 于是, 我们可以通过循环来优化它.

1.2 组成

初始化条件.

假设用int类型的变量x记录循环次数,x从1开始数, 数到100刚好100次, 1在这里充当的角色就是: 初始化条件.
判断条件.

变量x从1开始数, 数到100结束. 即: x <= 100, 这就是判断条件, 用来决定循环是否继续执行的.
控制条件.

用来控制变量x变化的. 每循环一次, 变量x的值+1. 即: x++就是控制条件.
循环体.

指的是需要重复执行的代码, 例如: System.out.println("Hello World!");

1.3 分类

for循环

一般适用于循环次数固定的情况.
while循环

一般适用于循环次数不固定的情况.
do.while循环

我们在实际开发中, 基本不用. 适用于先执行一次, 然后判断的情况.

2. for循环

for循环是我们在实际开发中应用到的最多的循环, 它一般适用于循环次数固定的情况.

2.1 格式

for(初始化条件1; 判断条件2; 控制条件3) {
    //循环体4;
}

解释:

初始化条件: 用来记录循环的初始状态的. 即: 从哪开始循环.

判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.

控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.

循环体: 需要用来重复做的事情(代码).

2.2 执行流程

先执行初始化条件.
然后执行判断条件, 看其结果是true, 还是false.
如果是false, 则整个循环结束.
如果是true, 则执行循环体.
执行控制条件.
返回第2步, 继续往下重复执行.

简单理解:

第一次执行: 1, 2, 4, 3. 假设判断条件成立.

重复执行: 2, 4, 3.

最后一次执行: 2 判断条件不成立, 循环结束.

2.3 图解

2.4 案例一: for循环入门

需求
通过for循环, 打印10次"Hello World!".

参考代码

//需求: 打印10次HelloWorld
public class ForDemo01 {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello World!");
        }
    }
}

2.5 案例二: 打印数字

需求

通过for循环, 打印1~5之间的数字.
通过for循环, 打印5~1之间的数字.

参考代码

public class ForDemo02 {
    public static void main(String[] args) {
        //1. 通过for循环, 打印1~5之间的数字.
        for (int i = 1; i <= 5 ; i++) {
            System.out.println(i);
        }
        System.out.println("--------------");

        //2. 通过for循环, 打印5~1之间的数字.
        //ritar
        for (int i = 5; i >= 1; i--) {
            System.out.println(i);
        }
    }
}

2.6 案例三: 求和案例

需求

通过for循环, 获取1 ~ 5之间的数字之和.

参考代码

public class ForDemo03 {
    public static void main(String[] args) {
        //1. 定义变量sum, 用来记录数据和.
        int sum = 0;
        //2. 通过for循环, 依次获取到1~5之间的数字.
        for (int i = 1; i <= 5; i++) {
            //3. 将获取到的数字, 累加给变量sum.
            sum += i;
        }
        System.out.println("1 - 5之间的数字之和是: " + sum);
    }
}

细节: 求和变量必须定义到for循环的外边, 如果定义到for循环的内容, 则每次循环都会被重置.

2.7 案例四: 求偶数和

需求
求1-100之间的偶数和，并把求和结果打印到控制台上.

参考代码

public class ForDemo04 {
    public static void main(String[] args) {
        //1. 定义变量sum, 用来记录数据和.
        int sum = 0;
        //2. 通过for循环, 依次获取到1 - 100之间的数字.
        for (int i = 1; i <= 100; i++) {
            //3. 判断当前遍历到的数字是否是偶数.
            if (i % 2 == 0) {
                //4. 走到这里, 说明是偶数, 累加给变量sum.
                sum += i;
            }
        }
        //5. 打印结果.
        System.out.println("1 - 100之间的偶数之和是: " + sum);
    }
}

2.8 案例五: 获取水仙花数

需求

获取到所有的水仙花数, 并将结果打印到控制台上.

解释:

水仙花数是一个3位数的整数.

该数字的各个位数立方和相加等于它本身.

例如: 153就是水仙花数, 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3 = 153

参考代码

public class ForDemo05 {
    public static void main(String[] args) {
        int ge, shi, bai;
        for (int i = 100; i < 1000; i++) {
            ge = i / 1 % 10;
            shi = i / 10 % 10;
            bai = i / 100 % 10;
            if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai)
                System.out.println(i);
        }
    }
}

2.9 案例六: 计数思想

需求

统计所有水仙花数的个数, 并将其打印到控制台上.

参考代码

public class ForDemo06 {
    public static void main(String[] args) {
        int ge, shi, bai,count = 0;
        for (int i = 100; i < 1000; i++) {
            ge = i / 1 % 10;
            shi = i / 10 % 10;
            bai = i / 100 % 10;
            if (i == ge * ge * ge + shi * shi * shi + bai * bai * bai)
                count++;
        }
        System.out.println("水仙花数的个数为: " + count);
    }
}

2.10 案例七: 求和 + 计数

需求

获取1 - 100之间的奇数和, 以及奇数的个数.

参考代码

//需求: 获取1 - 100之间的奇数和, 以及奇数的个数.
public class ForDemo07 {
    public static void main(String[] args) {
        int count = 0;
        int sum = 0;
        for (int i = 1; i <= 100 ; i++) {
            if (i % 2 != 0) {
                sum += i;
                count++;
            }
        }
        System.out.println("1-100之间的奇数个数为: " + count + ", 这些奇数的总和为: " + sum);
    }
}

2.11 案例八: 换行输出

需求

把1~100之间的数字, 按照6个一行的格式进行输出.

参考代码

public class ForDemo08 {
    public static void main(String[] args) {
        int flag = 6;
        int count = 0;
        for (int i = 1; i <= 100 ; i++) {
            System.out.print(i + "\t");
            if (++count % flag == 0)
                System.out.println();
        }
    }
}

3. while循环

while循环也是我们在实际开发中应用到的比较多的循环, 它一般适用于循环次数不固定的情况.

3.1 格式

初始化条件1;
while(判断条件2) {
    //循环体3;
    //控制条件4;
}

解释:

初始化条件: 用来记录循环的初始状态的. 即: 从哪开始循环.

判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.

控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.

循环体: 需要用来重复做的事情(代码).

3.2 执行流程

先执行初始化条件.
然后执行判断条件, 看其结果是true, 还是false.
如果是false, 则整个循环结束.
如果是true, 则执行循环体.
执行控制条件.
返回第2步, 继续往下重复执行.

简单理解:

第一次执行: 1, 2, 3, 4. 假设判断条件成立.

重复执行: 2, 3, 4.

最后一次执行: 2 判断条件不成立, 循环结束.

3.3 图解

3.4 案例一: while循环入门

需求

在控制台打印10次HelloWorld.

参考代码

public class WhileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        while(i < 10) {
            System.out.println("Hello World!");
            i++;
        }
    }
}

3.5 案例二: 求和

需求

获取1~100之间所有偶数和, 并将结果打印到控制台上.

参考代码

//需求: 获取1 - 100之间的偶数和.
public class WhileDemo02 {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        while (i <= 100) {
            if (i % 2 == 0)
                sum += i;
            i++;
        }
        System.out.println("1-100之间的偶数和为: " + sum);
    }
}

3.6 案例三: 珠穆朗玛峰

需求

已知世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米).
假如我有一张足够大的纸，它的厚度是0.1毫米.
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

即: 纸张的厚度 >= 珠穆朗玛峰的高度

参考代码

//案例: 珠穆朗玛峰
public class WhileDemo03 {
    public static void main(String[] args) {
        //1. 定义变量, 记录纸张的厚度.
        double paper = 0.1;
        //2. 定义变量, 记录珠峰的高度.
        int zf = 8844430;
        //3. 定义变量, 记录纸张的折叠次数.
        int count = 0;
        //4. 通过while循环实现, 获取折叠次数.
        while (paper < zf) {
            paper *= 2;
            count++;
        }
        //5. 打印结果.
        System.out.println("折叠次数为: " + count);
    }
}

4. do.while循环

do.while循环在实际开发中应用到的并不是特别多, 所以我们简单的了解下它的用法即可.

4.1 格式

初始化条件;
do {
    循环体;
    控制条件;
} while(判断条件);

解释:

初始化条件: 用来记录循环的初始状态的. 即: 从哪开始循环.

判断条件: 用来决定循环是否继续执行的, 条件成立, 则循环继续执行, 条件不成立, 整个循环就结束了.

控制条件: 用来控制初始化条件变化的, 一般是每循环一次, 初始化条件+1.

循环体: 需要用来重复做的事情(代码).

4.2 执行流程

先执行初始化条件.
再执行循环体.
再执行控制条件.
执行判断条件, 看其结果是true还是false.
如果是false, 则整个循环结束.
如果是true, 则返回第2步重复往下执行.

简单理解:

第一次执行: 1, 2, 3, 4. 假设判断条件成立.

重复执行: 2, 3, 4.

最后一次执行: 2 判断条件不成立, 循环结束.

4.3 图解

4.4 案例: 打印HelloWorld

需求
通过do.while循环, 在控制台打印10次Hello World!

参考代码

public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i = 1;
        do{
            System.out.println("Hello World! " + i);
            i++;
        }while(i <= 10);
    }
}

5. 循环扩展

5.1 三种循环之间的区别

do.while循环和其他两个循环之间的区别

do.while循环是先执行一次, 后判断.
而其他两个循环都是先执行判断条件, 然后决定是否执行循环体.

for循环和其他两个循环之间的区别
- for循环执行结束后, 初始化条件就不能继续使用了.
- 而其他两个循环执行结束后, 初始化条件还可以继续使用.

5.2 死循环

5.2.1 概述

所谓的死循环指的是永不会结束的循环, 也就是循环的判断条件永远为true,

在后期的开发中，会出现使用死循环的场景，例如：我们需要读取用户输入的输入，但是用户输入多少数据我们并不清楚，也只能使用死循环，当用户不想输入数据了，就可以结束循环了，如何去结束一个死循环呢，就需要使用到跳出语句了。

5.2.2 分类

在Java中, 死循环的写法格式主要有以下3种:

for(;;) { }
while(true){ }
do { } while(true)

5.2.3 参考代码

public class DeadLoop {
    public static void main(String[] args) {
        /*for(;;) {
            System.out.println("Hello World!");
        }*/

        /*while(true) {
            System.out.println("Hello World!");
        }*/

        do {
            System.out.println("Hello World!");
        } while(true);
    }
}

6. 练习

6.1 案例一

需求

按照从大到小的顺序输出四位数中的个位+百位=十位+千位(3553,2332,1166,8228,3773)的数字及个数.
每行输出5个满足条件的数，之间用空格分隔
如：9999 9988 9977 9966 9955

参考代码

6.2 案例二

需求

从键盘上录入一个大于100的三位数,求出100到该数字之间满足如下要求的数字之和, 要求如下:

数字的个位数不为7;
数字的十位数不为5;
数字的百位数不为3;

参考代码

Java基础（2）流程控制及关系运算符

1. 流程控制

1.1 概述

1.2 分类

1.3 顺序结构

2. 选择结构之if语句

2.1 概述

2.2 分类

2.3 单分支

2.4 双分支

2.4.1 格式

2.4.2 执行流程

2.4.3 图解

2.4.5 案例一: if格式二入门

2.4.6 案例二: 判断奇偶数

2.5 多分支

2.5.1 格式

2.4.2 执行流程

2.4.3 图解

2.4.4 案例一: 打印星期

2.4.5 案例二: 发放奖励

2.4.6 案例三: 获取最大值

3. 选择结构之switch语句

3.1 概述

3.2 格式

3.4 格式详解

3.5 执行流程

3.6 执行流程图解

3.7 示例一: 春夏秋冬

3.8 case穿透

3.9 思考题

3.10 案例二: 发放奖励

4 练习题

4.1 案例一: 涨工资.

4.2 案例二: 定义计算器

4.3 案例三: 水仙花数

今日目标

1. 关系运算符

1.1 概述

1.2 注意事项

1.3 案例

2. 逻辑运算符

2.1 概述

2.2 分类

2.3 示例: 逻辑运算符入门

2.4 短路逻辑运算符

2.4.1 格式

2.4.2 解释

2.4.3 短路和非短路之间的区别

2.4.4 案例

3. 三元运算符

3.1 格式

3.2 执行流程

3.3 案例一: 入门案例

3.4 案例二: 判断老虎体重

3.5 案例三: 获取和尚的最高身高

4. 键盘录入

4.1 概述

4.2 使用步骤

4.3 案例一: Scanner入门

4.4 案例二: 键盘录入版和尚身高

IDEA常用快捷键

4.1 练习1

4.2 练习2

4.3 练习3

循环

1. 循环结构

1.1 概述

1.2 组成

1.3 分类

2. for循环

2.1 格式

2.2 执行流程

2.3 图解

2.4 案例一: for循环入门

2.5 案例二: 打印数字

2.6 案例三: 求和案例

2.7 案例四: 求偶数和

2.8 案例五: 获取水仙花数

2.9 案例六: 计数思想