day02_运算符_流程控制

1.运算符

1.1 算术运算符

算术运算符有 + - * / % ，其中*表示乘法，/表示除法，%表示取余数

注意点：

/: 两个整数相除，结果也是一个整数

%: 表示两个数相除，取余数

符号	作用	说明
+	加	数学意义的加
-	减	数学意义的减
*	乘	数学意义的乘
/	除	数学意义的除，但是只会得到商，得不到余数
%	取余	获取两个数做除法后得到的余数

 代码示例：

public class OperatorDemo1 {
    public static void main(String[] args) {
        // 目标：掌握基本的算术运算符的使用。
        int a = 10;
        int b = 2;
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b); // 20
        System.out.println(a / b); // 5
        System.out.println(5 / 2); // 2.5 ==> 2
        System.out.println(5.0 / 2); // 2.5
        int i = 5;
        int j = 2;
        System.out.println(1.0 * i / j); // 2.5

        System.out.println(a % b); // 0
        System.out.println(3 % 2); // 1

        System.out.println("---------------------------------------");

        // 目标2：掌握使用+符号做连接符的情况。
        int a2 = 5;
        System.out.println("abc" + a2); // "abc5"
        System.out.println(a2 + 5); //  10
        System.out.println("doit" + a2 + 'a'); // "doit5a"
        System.out.println(a2 + 'a' + "doit"); // 102doit
    }
}

1.2自增自减运算符

接下来，学习一种比较常用的运算符：++和--

++读作自增，--读作自减； 运算规则如下

这玩意儿很恶心：

1.单独使用：++或者--放在变量前面没有区别

int a =10;

a++; //11

--a; //10

System.out.println(a); //10

2.混合使用：++或者--放在变量或者前面运算规则不相同

//++在后：先做其他事情，再做自增和自减

int a = 10;

int b = a++; //等价于 int b = a; a++;

//++在前：先自增或者自减，再做其他运输

int x = 10;

int y = --x; //等价于x--; int y = x;

代码示例：

public class OperatorDemo2 {
    public static void main(String[] args) {
        // 目标：掌握自增自减运算符的使用。
        int a = 10;
        // a++; // a = a + 1
        ++a;
        System.out.println(a);

        // a--; // a = a - 1
        --a;
        System.out.println(a);

        // 自增自减只能操作变量不能操作字面量的，会报错！
              //System.out.println(2++);

        System.out.println("--------------------------------------");

        int i = 10;
        int rs = ++i; // 先加后用
        System.out.println(rs);
        System.out.println(i);

        int j = 10;
        int rs2 = j++; // 先用后加
        System.out.println(rs2);
        System.out.println(j);
    }
}

1.3赋值运算符

解释说明

int a = 10;

//+=解析：在a原来记录值10的基础上累加5，将结果重新赋值给a;

a+=5;

//最终打印a的值为15

System.out.println(a);

代码示例：

public class OperatorDemo3 {
    public static void main(String[] args) {
        // 目标：掌握扩展赋值运算符的使用。
        // +=
        // 需求：收红包
        double a = 9.5;
        double b = 520;
        a += b;  // a = (double)(a + b);
        System.out.println(a);

        // -= 需求：发红包
        double i = 600;
        double j = 520;
        i -= j;  // i = (double)(i - j);
        System.out.println(i);

        int m = 10;
        int n = 5;
        // m *= n; // 等价形式： m = (int)(m * n)
        // m /= n; // 等价形式： m = (int)(m / n)
        m %= n;    // 等价形式： m = (int)(m % n)
        System.out.println(m);
    }
}

3.4 关系运算符

代码示例：

public class OperatorDemo4 {
    public static void main(String[] args) {
        // 目标：掌握关系运算符的基本使用。
        int a = 10;
        int b = 5;
        boolean rs = a > b;
        System.out.println(rs);

        System.out.println(a >= b); // 要么a大于b,或者a等于b
        System.out.println(2 >= 2); // true
        System.out.println(a < b);
        System.out.println(a <= b); // false
        System.out.println(2 <= 2); // true
        System.out.println(a == b); // false
        System.out.println(5 == 5); // true
        
        // 注意了：判断是否相等一定是用 == ，=是用来赋值的。
        // System.out.println(a = b); 
        System.out.println(a != b); // true
        System.out.println(10 != 10); // false

        System.out.println(false ^ true ^ false);
    }
}

了解即可：后面用着用着就会啦

 

代码示例：

//需求1：要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8.
//需求2：要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8.
public class OperatorDemo5 {
    public static void main(String[] args) {
        // 目标：掌握逻辑运算符的使用。
        // 需求：要求手机必须满足尺寸大于等于6.95，且内存必须大于等于8.
        double size = 6.8;
        int storage = 16;
        // 1、& 前后的条件的结果必须都是true ,结果才是true.
        boolean rs = size >= 6.95 & storage >= 8;
        System.out.println(rs);

        // 需求2：要求手机要么满足尺寸大于等于6.95，要么内存必须大于等于8.
        // 2、| 只要多个条件中有一个是true,结果就是true.
        boolean rs2 = size >= 6.95 | storage >= 8;
        System.out.println(rs2);

        // 3、!取反的意思
        System.out.println(!true); // false
        System.out.println(!false); // true
        System.out.println(!(2 > 1)); // false

        // 4、^ 前后条件的结果相同时返回false，不同时返回true.
        System.out.println(true ^ true); // false
        System.out.println(false ^ false); // false
        System.out.println(true ^ false); // true
        System.out.println(false ^ true); // true

        // 5、&& 左边为false，右边不执行。
        int i = 10;
        int j = 20;
        // System.out.println(i > 100 && ++j > 99);
        System.out.println(i > 100 & ++j > 99);
        System.out.println(j);

        // 6、|| 左边是true ，右边就不执行。
        int m = 10;
        int n = 30;
        // System.out.println(m > 3 || ++n > 40);
        System.out.println(m > 3 | ++n > 40);
        System.out.println(n);
    }
}

3.6 三元运算符

语法格式：
关系表达式? 值1 : 值2;

执行流程：
首先计算关系表达式的值，如果关系表达式的值为true，则返回值1；如果关系表达式的值为false, 则返回值2；

代码示例：

public class OperatorDemo6 {
    public static void main(String[] args) {
        // 目标：掌握三元运算符的基本使用。
        double score = 58.5;
        String rs = score >= 60 ? "成绩及格" : "成绩不及格";
        System.out.println(rs);

        // 需求2：找出2个整数中的较大值，并输出。
        int a = 99;
        int b = 69;
        int max = a > b ? a : b;
        System.out.println(max);

        // 需求3：找3个整数中的较大值。
        int i = 10;
        int j = 45;
        int k = 34;

        // 找出2个整数中的较大值。
        int temp = i > j ? i : j;
        // 找出temp与k中的较大值。
        int max2 = temp > k ? temp : k;
        System.out.println(max2);
    }
}

2.程序流程控制

2.1 if分支

2.1.1 只有一个if

代码示例：

// 需求：测量用户体温，发现体温高于37度就报警。
double t = 36.9;
if(t > 37){
    System.out.println("这个人的温度异常，把他赶紧带走~~");
}

2.1.2 if...else...

代码示例：

// 需求2：发红包，你的钱包余额是99元，现在要发出90元
// 如果钱够触发发红包的动作，如果钱不够，则提示：余额不足。
double money = 19;
if(money >= 90){
    System.out.println("发红包成功了~");
}else {
    System.out.println("余额不足~~");
}

2.1.3 if...else if ... else if .......else

代码示例：

// 需求3：某个公司有一个绩效系统，根据员工的打分输出对应的绩效级别。[0,60) D  [60,80) C [80,90) B [90,100] A
int score = 298;
if(score >= 0 && score < 60) {
    System.out.println("您的绩效级别是： D");
}else if(score >= 60 && score < 80){
    System.out.println("您的绩效级别是： C");
}else if(score >= 80 && score < 90){
    System.out.println("您的绩效级别是： B");
}else if(score >= 90 && score <= 100){
    System.out.println("您的绩效级别是： A");
}else {
    System.out.println("您录入的分数有毛病~~");
}

2.2 switch分支

代码示例：

//说白了，一个个比过去，有一样的了就结束，没有一样的，就执行最后一个
/**
需求：
看看今天吃啥呗
礼拜一：鲍鱼海参
礼拜二：油焖大虾
礼拜三：吴老幺火锅
礼拜四：西城老太太烤肉
礼拜五：馒头
礼拜六：老干妈拌饭
礼拜天：土
*/
String day = "礼拜三";
switch (week){
    case "礼拜一":
        System.out.println("鲍鱼海参");
        break;
    case "礼拜二":
        System.out.println("油焖大虾");
        break;
    case "礼拜三":
        System.out.println("吴老幺火锅");
        break;
    case "礼拜四":
        System.out.println("西城老太太烤肉");
        break;
    case "礼拜五":
        System.out.println("馒头");
        break;
    case "礼拜六":
        System.out.println("老干妈拌饭");
        break;
    case "礼拜天":
        System.out.println("土");
        break;
    default:
        System.out.println("抬走，抬走");
}

switch得注意事项：

1. 表达式类型只能是byte、short、int、char，String，不支持double、float、double

2. case给出的值不允许重复，且只能是字面量，不能是变量。

3. 正常使用switch的时候，不要忘记写break，否则会出现穿透现象。

2.3循环结构

2.3.1 for循环

语法

for (初始化语句; 循环条件; 迭代语句) {
    循环体语句(重复执行的代码);
}

初始化语句：一般是定义一个变量，并给初始值
循环条件：一般是一个关系表达式，结果必须是true或者false
迭代语句：用于对条件进行控制，一般是自增或者自减
循环语句体：需要重复执行的代码

执行流程

for循环案例1——求和

求和的思路分析：
        1)首先需要定义一个求和变量，一般命名为sum
        2)再遍历得到所有需要求和的数据(1~100之间的所有整数)
        3)让需要求和的数据和sum累加，
        结果：所有数据累加完之后最终sum就是所有数据的和


//2.需求：求1~100中所有整数的和
int sum = 0;
//定义一个循环，先产生1-100，这100个数
for (int i = 1; i <= 100; i++) {
    //每产生一个数据，就把这个数和sum累加
    sum += i; //sum = sum  + i;
}
System.out.println("1-100的数据和：" +  sum);

2.2 for循环案例2——求奇数和

需求：求1~100之间奇数的和
求奇数和的思路（只是求和的数据变成了奇数，思路和前面没有变化）
        1)首先需要定义一个求和变量，这里命名为sum1
        2)再遍历得到所有需要求和的数据(1~100之间的所有奇数)
        3)让需要求和的数据和sum1累加，
        结果：所有数据累加完之后最终sum1就是所有数据的和
        
        
//1)定义一个变量用于求和
int sum1 = 0;
//2)定义一个循环产生1-100之间的奇数
for (int i = 1; i < 100; i+=2) {
    // i = 1 3 5 7 ...
    //3)让需要求和的数据和sum1累加，
    sum1 += i;
}
System.out.println("1-100之间的奇数和：" +  sum1);



求奇数和的思路（只是求和的数据变成了奇数，思路和前面没有变化）
        1)首先需要定义一个求和变量，这里命名为sum2
        2)再遍历得到所有需要求和的数据(1~100之间的所有整数)
        3)在求和之前先对数据判断，如果是奇数，才和sum1累加；否则什么也不干
        结果：所有数据累加完之后最终sum1就是所有数据的和
        
//1)首先需要定义一个求和变量，这里命名为sum2
int sum2 = 0; 
//2)再遍历得到所有需要求和的数据(1~100之间的所有整数)
for (int i = 1; i <= 100; i++) {
    //i = 1 2 3 4 5 6 ... 99 100
    //3)在求和之前先对数据判断，如果是奇数，才和sum1累加；否则什么也不干
    if(i % 2 == 1){
        // i = 1 3 5 7 9 ... 99
        sum2 += i;
    }
}
System.out.println("1-100之间的奇数和：" + sum2); 

2.3.2 while循环

语法：

代码示例：

// 需求：打印5行Hello World
int i = 0;
while (i < 5) {
    // i = 0 1 2 3 4
    System.out.println("Hello World");
    i++;
}

 for、while如何选择

学到这里，细心的同学可能会发现while循环和for循环的执行流程是一样的。那他们是不是可以通用呢？

• 从功能来说：能够用for循环做的，都能用while循环做。

• 使用规范上来说：知道循环几次，建议使用for；不知道循环几次建议使用while

while循环案例——折纸案例

需求：世界最高山峰珠穆朗玛峰高度是：8848.86米=8848860毫米，假如我有一张足够大的它的厚度是0.1毫米。请问：该纸张折叠多少次，可以折成珠穆朗玛峰的高度？


分析：首先由于不知道折叠多少次，我们可以选择用while循环
        1)纸张的初始化厚度为0.1毫米，珠峰的高度为8848860毫米
                double peakHeight = 8848860;
                double paperThickness = 0.1;
        2)每次折叠纸张的厚度为原来的两倍，这是需要循环执行的
                while(纸张厚度<8848860){
                        纸张厚度*=2;
                }
        3)需要求折叠的次数，可以用一个变量来记录折叠的次数
                int 次数 = 0;
                while(纸张厚度<8848860){
                        纸张厚度*=2;
            次数++; //每次折叠次数累加
                }
        结果：等循环结束之后，打印记录次数的值，就是折叠多少次了。



// 1、定义变量记住珠穆朗玛峰的高度和纸张的高度。
double peakHeight = 8848860;
double paperThickness = 0.1;

// 3、定义一个变量count用于记住纸张折叠了多少次
int count = 0;

// 2、定义while循环控制纸张开始折叠
while (paperThickness < peakHeight) {
    // 把纸张进行折叠，把纸张的厚度变成原来的2倍。
    paperThickness = paperThickness * 2;
    count++;
}
System.out.println("需要折叠多少次：" + count);
System.out.println("最终纸张的厚度是：" + paperThickness);

2.3.3 do-while循环

语法：

小总结

1. for循环 和 while循环（先判断后执行）; do...while （先执行后判断）

2. for循环和while循环的执行流程是一模一样的，

   1. 功能上无区别，for能做的while也能做，反之亦然。

   2. 如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。

3. for循环中控制循环的变量只在循环中使用。while循环中，控制循环的变量在循环后还可以继续使用

2.2.4死循环

写法：

//for死循环
for ( ; ; ){
    System.out.println("Hello World1");
}

//while死循环
while (true) {
    System.out.println("Hello World2");
}

//do-while死循环
do {
    System.out.println("Hello World3");
}while (true);

应用场景

有时候想要一直跑一个程序，比如造数据，服务器得程序不能停等

2.2.5循环嵌套

所谓循环嵌套，就是一个循环中又包含另一个循环（就是同学们常说的，套娃^_^）

代码示例：

i=0时; i<3为true; 进入循环
        //j的取值从0到5,执行一轮，打印5次"我爱你"
        for(int j = 1; j <= 5; j++) {
       System.out.println("我爱你：" + i);
    }
    内层循环执行完之后，执行外层的i++; i的值1
    
i=1时：i<3为true; 进入循环
        //j的取值从0到5,又执行一轮，打印5次"我爱你"
        for(int j = 1; j <= 5; j++) {
       System.out.println("我爱你：" + i);
    }
    内层循环执行完之后，执行外层的i++; i的值2
    
i=2时：i<3为true; 进入循环
        //j的取值从0到5,再执行一轮，打印5次"我爱你"
        for(int j = 1; j <= 5; j++) {
       System.out.println("我爱你：" + i);
    }
    内层循环执行完之后，执行外层的i++; i的值3
    
i=3时：i<3为false; 外层循环结束

小练习：

需求：在控制台使用 * 打印出4行5列的矩形
    ****
    ****
    ****
    ****
    
    
//1)先写一个循环用来在一行中打印5个"*"
for (int j = 1; j <= 5; j++) {
    System.out.print("*"); // 不换行
}
System.out.println(); //换行


System.out.println("-----------------");

//2)再将第一步的代码套一层循环，执行4次，就可以打印4行
for (int i = 1; i <= 4; i++) {
    for (int j = 1; j <= 5; j++) {
        System.out.print("*"); // 不换行
    }
    System.out.println(); //换行
}

课后练习：打印99乘法表

2.2.6跳转语句 break 、continue

如果循环到一半不想循环了怎么办呢？，用break和continue两个关键字就可以搞定

• break作用：跳出并结束当前所在循环的执行

• continue作用：结束本次循环，进入下一次循环

案例1：演示break的使用，提前终止循环的执行

// 1、break:跳出并结束当前所在循环的执行。
// 场景：假如你又有老婆了，你犯错了，你老婆罚你说：5句我爱你
// 说到第三句的时候心软了，让你别再说了。
for (int i = 1; i <= 5; i++) {
    System.out.println("我爱你：" + i);
    if(i == 3){
        // 说明已经说完了第三句了，心软了。
        break; // 跳出并结束当前所在循环的执行。
    }
}

案例2：演示continue的使用，结束循环中的一次，继续下一次循环

// 2、continue:跳出当前循环的当次执行，直接进入循环的下一次执行。
// 场景: 假如你有老婆，你犯错了，你老婆罚你洗碗5天。
// 第三天的时候，你表现很好，第三天不用洗碗，但是不解恨，第四天还是要继续的。
for (int i = 1; i <= 5; i++) {
    if(i == 3) {
        // 已经到了第三天，第三天不用洗的。
        continue;
    }
    System.out.println("洗碗：" + i);
}

3.键盘录入

键盘录入这个事情，其实并不是我们自己做的，这是别人写好得功能，我们直接拿过来用的。

【第1步】：在class类上导包：一般不需要我们自己做，idea工具会自动帮助我们 导包的。
    import java.util.Scanner;
【第2步】：得到一个用于键盘扫描器对象（照抄代码就行，固定格式）
    //Scanner是键盘扫描器对象(你就把它理解成一个东西)，这个东西有录入的功能
    //sc是给这个东西取的名字
    Scanner sc = new Scanner(System.in);

【第3步】：开始调用sc的功能，来接收用户键盘输入的数据。
    //sc这个东西有键盘录入整数的功能，这个功能的名字叫nextInt()
    //.表示表示调用的意思
    int age = sc.nextInt();
    System.out.println("我的年龄是:"+age);

    //sc这个东西还有键盘录入字符串的功能，这个功能的名字叫next
    String name = sc.next();
    System.out.println("我的姓名是:"+name);

代码示例：

public class ScannerDemo1 {
    public static void main(String[] args) {
        // 1、导包:一般不需要我们自己做，idea工具会自动帮助我们 导包的。
        // 2、抄写代码：得到一个键盘扫描器对象（东西）
        Scanner sc = new Scanner(System.in);

        // 3、开始 调用sc的功能，来接收用户键盘输入的数据。
        System.out.println("请您输入您的年龄：");
        int age = sc.nextInt(); // 执行到这儿，会开始等待用户输入一个整数，直到用户按了回车键，才会拿到数据。
        System.out.println("您的年龄是："  + age);

        System.out.println("请您输入您的名字：");
        String name = sc.next(); // 执行到这儿，会开始等待用户输入一个字符串，直到用户按了回车键，才会拿到数据。
        System.out.println(name + "欢迎您进入系统~~");
    }
}

4.随机数

随机数也是一样，都是别人写好的代码，直接拿过来用就行。

// 目标：掌握使用Random生成随机数的步骤。
// 1、导包。import java.util.Random; (idea会自动完成)
import java.util.Random;
public class RandomDemo1 {
    public static void main(String[] args) {
        // 2、创建一个Random对象，用于生成随机数。
        Random r = new Random();
        // 3、调用Random提供的功能：nextInt得到随机数。
        for (int i = 1; i <= 20; i++) {
            int data = r.nextInt(10); // 0 - 9
            System.out.println(data);
        }
    }
}

5.综合案例之猜数字小游戏

需求：
        随机生成一个1-100之间的数据，提示用户猜测，猜大提示过大，猜小提示过小，直到猜中          结束游戏

分析：
        1.先随机生成一个1-100之间的数据。
                谁可以帮你生成随机数啊？ 是不是要用到Random？
                
        2.定义一个死循环让用户可以一直猜测。
                用户猜的数据从哪里来啊？ 是不是要用到Scanner?

        3.在死循环里，每次让用户录入的数据和随机数进行比较
                如果比随机数大：提示猜大了
                如果比随机数小：提示猜小了
                如果和随机数相同：提示恭喜你猜中了

代码示例

import java.util.Random;
import java.util.Scanner;

public class RandomTest2 {
    public static void main(String[] args) {
        // 1、随机产生一个1-100之间的数据，做为中奖号码。
        Random r = new Random();
        int luckNumber = r.nextInt(100) + 1;

        // 2、定义一个死循环，让用户不断的猜测数据
        Scanner sc = new Scanner(System.in);
        while (true) {
            // 提示用户猜测
            System.out.println("请您输入您猜测的数据：");
            int guessNumber = sc.nextInt();

            // 3、判断用户猜测的数字与幸运号码的大小情况
            if(guessNumber > luckNumber){
                System.out.println("您猜测的数字过大~~");
            }else if(guessNumber < luckNumber){
                System.out.println("您猜测的数字过小~~");
            }else {
                System.out.println("恭喜您，猜测成功了，可以买单了~~");
                break; // 结束死循环
            }
        }
    }
}