JavaSE基础(三)-----运算符及程序逻辑控制

目录

1、运算符

1.1算术运算符

1.1.1基本的四则运算符

1.1.2增量运算符+=、-=、*=、/=

1.1.3自增自减运算符

1.2关系运算符

1.3逻辑运算符*

1.4位运算符

1.5移位运算符

1.5.1左移运算符<<

1.5.2右移运算符>>

1.5.3无符号右移运算符>>>

1.6条件运算符

1.7、运算符的优先级

2、程序逻辑控制

2.1、分支结构

2.1.1 if语句

2.1.2switch语句

2.2循环结构

2.2.1while循环

2.2.2break语句

2.2.3continue语句

2.2.4for循环*

2.2.5do while循环（不推荐用）

3.输入输出

3.1输出到控制台

3.2从键盘上输入*

4.猜数字练习

---

1、运算符

Java作为一门计算机语言，也像c语言提供了一套丰富的运算符来操纵变量。Java中运算符可分为以下：算术运算符(+ - * /)、 关系运算符(< > ==)、逻辑运算符(&&、||)、位运算符(&、|、~、^)、移位运算符(>>、<<、>>>)以及条件运算符等。

int a=2;
int b=4;
a<b;
b+=a;
if(a<3&&b>3) {
    System.out.println(a+b);
}

---

1.1算术运算符

1.1.1基本的四则运算符

基本四则运算符：加减乘除模(+ - * / %)

(1)

int a = 20;
int b = 10;
System.out.println(a + b); // 30
System.out.println(a - b); // 10
System.out.println(a * b); // 200
System.out.println(a / b); // 2
System.out.println(a % b); // 0 --->模运算相当于数学中除法的余数

【注意】：当两个int类型的值进行相除时，如果得出得结果有小数，则丢弃小数位保留整数位（向下取整），但可以用浮点型来表示出来。

int a=5,b=2;
System.out.println(a/b);//结果为2
double i=a/b;
System.out.println(i); //结果为2.5

(2)做除法和取模时，右操作数不能为0,否则编译时会报错

int a = 1;
int b = 0;
System.out.println(a / b)
// 运行结果
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Test.main(Test.java:5)

(3)当进行运算的两个操作数的数据类型不一样时，所占字节小的会向大的类型进行类型提升，如果是像short、char、byte这类小于4个字节的，会提升为int类型再进行运算。

System.out.println(1+0.2); // +的左侧是int，右侧是double，在加之前int被提升为double
//结果为1.2

1.1.2增量运算符+=、-=、*=、/=

该种类型运算符操作完成后，会将操纵的结果赋值给左操作数。

int a=3;
a+=1;            //相当于a=a+1
System.out.println(a); 
a-=1;            //相当于a=a-1
System.out.println(a); 
a*=3;            //相当于a=a*3

【注意】：(1)只有变量才能使用该运算符，常量不能使用

                  (2)如果进行增量的两个数类型不一致，则此处会自动进行类型转换（类似隐式类型转换）

其输出结果为

1.1.3自增自减运算符

++是给变量的值+1，--是给变量的值-1。

int a = 1;
a++; // 后置++ 表示给a的值加1，此时a的值为2
System.out.println(a++); // 注意：后置++是先使用变量原来值，表示式结束时给变量+1，因此输出2
System.out.println(a); // 输出3
++a; // 前置++ 表示给a的值加1
System.out.println(++a); // 注意：前置++是先给变量+1，然后使用变量中的值，因此输出5
System.out.println(a); // 输出5
// --操作符给操作-1，与++含义类似

【注意】：

（1）如果单独使用，【前置++】和【后置++】没有任何区别

（2）如果混合使用，【前置++】先+1，然后使用变量+1之后的值，【后置++】先使用变量原来的值，表达式 结束时给变量+1

（3）只有变量才能使用自增/自减运算符，常量不能使用，因为常量不允许被修改

---

1.2关系运算符

关系运算符主要有六个: == != < > = ，其计算结果是 true 或者 false 。

int a = 10;
int b = 20;
// 注意：在Java中 = 表示赋值，要与数学中的含义区分
// 在Java中 == 表示相等
System.out.println(a == b); // false
System.out.println(a != b); // true
System.out.println(a < b); // true
System.out.println(a > b); // false
System.out.println(a <= b); // true
System.out.println(a >= b); // false

注意：当需要多次判断时，不能连着写，比如：3 < a < 5，Java程序与数学中是有区别的，应当写成(a>3&&a<5)

---

1.3逻辑运算符*

逻辑运算符主要有三个: && || ! ，运算结果都是 boolean类型。（注意：不能再像c语言那样用1或0表示true和false）。

1.、逻辑与 &&

语法规则：表达式1 && 表达式2，左右表达式必须是boolean类型的结果。

两个表达式只要一个为假，结果就是假（第一个为假，表达式2就不会再进行，因为无论表达式2为真还是假，结果都是假）；表达式两个都是真，结果才是真。

表达式1	表达式2	结果
真	真	真
真	假	假
假	真	假
假	假	假

2 、逻辑或||

语法规则：表达式1 || 表达式2，左右表达式必须是boolean类型的结果。

两个表达式只要有其中一个为真，则结果就为真（因此只要表达式1为真，表达式2就不会在进行运行判断）；两个表达式都为假，结果才为假。 

表达式1	表达式2	结果
真	真	真
真	假	真
假	真	真
假	假	假

3、逻辑非！

语法规则：! 表达式 真变假，假变真。

4、*短路求值

&& 和 || 遵守短路求值的规则

正常情况下，遇到10/0这种除数为0的时候，运行程序后是会报错的，但此处10/0并没有真正被求值。

System.out.println(10 > 20 && 10 / 0 == 0); // 打印 false
System.out.println(10 < 20 || 10 / 0 == 0); // 打印 true

 【注意】：

• 对于 && , 如果左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式.
• 对于 ||, 如果左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式.
• & 和 | 如果表达式结果为 boolean 时, 也表示逻辑运算. 但与 && || 相比, 它们不支持短路求值，无论表达式1是真是假，表达式2都会继续计算。

 例：

System.out.println(10 > 20 & 10 / 0 == 0); // 程序抛出异常
System.out.println(10 < 20 | 10 / 0 == 0); // 程序抛出异常

---

1.4位运算符

Java 中数据存储的最小单位是字节，而数据操作的最小单位是比特位.字节是最小的存储单位，每个字节是由8个二 进制比特位组成的，多个字节组合在一起可以表示各种不同的数据。

位运算符主要有四个: & | ~ ^ ，除 ~ 是一元运算符外，其余都是二元运算符。

位操作表示 按二进制位运算. 计算机中都是使用二进制来表示数据的(01构成的序列), 按位运算就是在按照二进制位的 每一位依次进行计算

（1）按位与&：如果两个二进制位都是 1, 则结果为 1, 否则结果为 0.

int a=10,b=20;
System.out.println(a&b);

进行按位运算, 需要先把 10 和 20 转成二进制, 分别为 1010 和 10100 

（2）按位或|：如果两个二进制位都是 0, 则结果为 0, 否则结果为 1.

int a = 10，b=20;
System.out.println(a | b)

 与上图同理

【注意】：注意: 当 & 和 | 的操作数为整数(int, short, long, byte) 的时候, 表示按位运算, 当操作数为 boolean 的时候, 表示 逻辑运算.

（3）按位取反 ~: 如果该位为 0 则转为 1, 如果该位为 1 则转为 0

运行结果为

【注意】：

（1）0x 前缀的数字为 十六进制 数字. 十六进制可以看成是二进制的简化表示方式. 一个十六进制数字对应 4 个 二进制位.

（2）0xf 表示 10 进制的 15, 也就是二进制的 1111

（3）printf 能够格式化输出内容, %x 表示按照十六进制输出.

（4）\n 表示换行符 

（4）按位异或^：如果两个数字的二进制位相同, 则结果为 0, 相异则结果为 1.

【注意】：如果两个数相同，则异或的结果为0

---

1.5移位运算符

 移位运算符有三个: > >>> ，都是二元运算符，且都是按照二进制比特位来运算的。

1.5.1左移运算符<<

左移 <<: 最左侧位不要了, 最右侧补 0.

比如10的二进制为0000 1010，左移之后为0001 0100结果为20（打印结果都是16进制打印的）

int a = 0x10;
System.out.printf("%x\n", a << 1);
// 运行结果(注意, 是按十六进制打印的)
20

【注意】：向左移位时，丢弃的是符号位，因此正数左移可能会变成负数。

左移可以直接理解成该数乘2

1.5.2右移运算符>>

右移 >>: 最右侧位不要了, 最左侧补符号位(正数补0, 负数补1)

int a = 0x10;
System.out.printf("%x\n", a >> 1);
// 运行结果(注意, 是按十六进制打印的)
8
int b = 0xffff0000;
System.out.printf("%x\n", b >> 1);
// 运行结果(注意, 是按十六进制打印的)
ffff8000

右移可以直接理解成该数除2

例（1）：如果该数是正数（右移除2，向下取整）

 

例（2）：如果该数是负数（右移除2，向上取整）

 【原理】：在进行右移运算时，把该负数转化为补码（16进制）进行右移，该数-3原码为：

1000 0000 0000 0000 0000 0000 0000 0011，转为补码为：1111 1111 1111 1111 1111 1111 1111 1101，进行右移1位后为：1111 1111 1111 1111 1111 1111 1111 1110，最后再以原码的形式打印出来：1000 0000 0000 0000 0000 0000 0000 0010，结果为（-2）

1.5.3无符号右移运算符>>>

无符号右移 >>>: 最右侧位不要了, 最左侧补 0.

int a = 0xffffffff;
System.out.printf("%x\n", a >>> 1);
// 运行结果(注意, 是按十六进制打印的)
7fffffff

【注意】：

1. 左移 1 位, 相当于原数字 * 2. 左移 N 位, 相当于原数字 * 2 的N次方.

2. 右移 1 位, 相当于原数字 / 2. 右移 N 位, 相当于原数字 / 2 的N次方.

3. 由于计算机计算移位效率高于计算乘除, 当某个代码正好乘除 2 的N次方的时候可以用移位运算代替.

4. 移动负数位或者移位位数过大都没有意义.

---

1.6条件运算符

条件运算符只有一个: 表达式1 ? 表达式2 : 表达式3

当 表达式1 的值为 true 时, 整个表达式的值为 表达式2 的值;

当表达式1的值为true时，整个表达式的值为表达式3的值

// 求两个整数的最大值
int a = 10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max);//此处输出的结果为20

【注意】：

1、表达式不能单独存在，其产生的结果必须要被使用。

int a = 10;
int b = 20;
a > b? a : b; // 报错：Error:(15, 14) java: 不是语句

2/表达式2和表达式3的结果要不是同类型的话，除非能发生类型隐式类型转换，否则不法运行

---

1.7、运算符的优先级

 在一条表达式中，各个运算符可以混合起来进行运算，但是运算符的优先级不同，比如：* 和 / 的优先级要高于 + 和 - 。

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + (b - a) >> 1;
System.out.println(c);

上述表达式中，由于 + 的优先级要高于 >> , 因此a先和b-a的结果做加法，整体为20，最后再进行右移，因此结果为 10。

【注意】：运算符之间是有优先级的. 具体的规则不必刻意记忆. 在可能存在歧义的代码中加上括号即可.

加上括号改变优先级即可

// 求a和b的平均值
int a = 10;
int b = 20;
int c = a + ((b - a) >> 1);
System.out.println(c);

上述表达式中，会对b-a的结果先进行右移后再加上a，最后才赋给c。结果为15。

---

2、程序逻辑控制

程序的逻辑控制语句大致分为三种结构：顺序结构（顺序结构比较简单，按照代码书写的顺序一行一行执行。）、循环结构、选择（分支）结构。

2.1、分支结构

2.1.1 if语句

//语法格式一
if(布尔表达式){
    // 语句
}
//如果布尔表达式结果为true，执行if中的语句，否则不执行。


//语法格式二
if(布尔表达式){
    // 语句1
}else{
    // 语句2
}
//如果布尔表达式结果为true，执行if中的语句，否则不执行。


//语法格式三
if(布尔表达式1){
    // 语句1
}else if(布尔表达式2){
    // 语句2
}else{
    // 语句3
}


//表达式1成立，执行语句1，否则表达式2成立，执行语句2，否则执行语句3

【练习一】：根据输入的年龄, 来打印出当前年龄的人是少年(低于18), 青年(19-28), 中年(29-55), 老年(56以上)

通过导入util，来输入一个数据，利用if/else 分支来判断年龄分类。键盘的输入下面会描述到。

【练习二】：输出1000到2000年之间所有的闰年

闰年为能被4整除但不会被100整除，或能被400整除的年份

对于Java中语法风格还是推荐以下写法

// 风格1-----> 推荐
int x = 10;
if (x == 10) {
// 语句1
} else {
// 语句2
}

【注意】：（一）分号问题 

int x = 20;
if (x == 10);
{
System.out.println("Oh");
}
// 运行结果
Oh

此处在if后出现了一个分号，导致致分号成为了 if 语句的语句体, 而 { } 中的代码已经成为了和一个 if 无关的代码块.无论条件结果为真为假，都会执行下面的语句。

（二）悬垂问题

int x = 10;
int y = 10;
if (x == 10)
    if (y == 10)
        System.out.println("aaa");
else
    System.out.println("bbb");

if / else 语句中可以不加 大括号 . 但是也可以写语句(只能写一条语句). 此时 else 是和最接近的 if 匹配. 但是实际开发中我们 不建议 这么写. 最好加上大括号

2.1.2switch语句

基本语法：

switch(表达式){
    case 常量值1:{
        语句1;
        break;
    }
    case 常量值2:{
        语句2;
        break;
    }
...
    default:{
        内容都不满足时执行语句;
        break;
    }
}

执行流程： 1. 先计算表达式的值

2. 和case依次比较，一旦有响应的匹配就执行该项下的语句，直到遇到break时结束

3. 当表达式的值没有与所列项匹配时，执行default

【注意】：

（1）多个case后的常量值不可以重复；

（2）switch的括号内只能是以下类型的表达式：

基本类型：byte、char、short、int，注意不能是long类型 引用类型：String常量串、枚举类型

double num = 1.0;
switch(num) {
    case 1.0:
        System.out.println("hehe");
        break;
    case 2.0:
        System.out.println("haha");
        break;
}
// 编译出错
Test.java:4: 错误: 不兼容的类型: 从double转换到int可能会有损失
                    switch(num) {
                          ^
1 个错误

 （3）break 不要遗漏, 否则会失去 "多分支选择" 的效果

int day = 1;
switch(day) {
    case 1:
        System.out.println("星期一");
        // break;
    case 2:
        System.out.println("星期二");
        break;
}
// 运行结果
星期一
星期二

（4）switch 不能表达复杂的条件

// 例如: 如果 num 的值在 10 到 20 之间, 就打印 hehe
// 这样的代码使用 if 很容易表达, 但是使用 switch 就无法表示.
if (num > 10 && num < 20) {
System.out.println("hehe");
}

（5）switch 虽然支持嵌套, 但是很丑，一般不推荐

---

2.2循环结构

2.2.1while循环

基本语法格式：

while(循环条件){
    循环语句;
}

while(循环条件){ 循环语句; }

示例一： 计算 5 的阶乘

int n = 1;
int result = 1;
while (n <= 5) {
    result *= n;
    n++;
}
System.out.println(num);
// 执行结果
120

示例二：计算 1! + 2! + 3! + 4! + 5!

int num = 1;
int sum = 0;
// 外层循环负责求阶乘的和
while (num <= 5) {
    int factorResult = 1;
    int tmp = 1;
// 里层循环负责完成求阶乘的细节.
while (tmp <= num) {
    factorResult *= tmp;
    tmp++;
}
sum += factorResult;
num++;
}
System.out.println("sum = " + sum);

【注意】：

1. 和 if 类似, while 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

2. 和 if 类似, while 后面的 { 建议和 while 写在同一行.

3. 和 if 类似, while 后面不要多写 分号, 否则可能导致循环不能正确执行

例如：

int num = 1;
while (num <= 10); {
System.out.println(num);
num++;
}
// 执行结果
[无任何输出, 程序死循环]

此时 ; 为 while 的语句体(这是一个空语句), 实际的 { } 部分和循环无关. 此时循环条件 num <= 10 恒成立, 导致代码 死循环了

2.2.2break语句

break 的功能是让循环提前结束.

代码示例: 找到 100 - 200 中第一个 3 的倍数

int num = 100;
while (num <= 200) {
if (num % 3 == 0) {
    System.out.println("找到了 3 的倍数, 为:" + num);
    break;
}
num++;
}
// 执行结果
找到了 3 的倍数, 为:102

        执行到 break 就会让循环结束.

2.2.3continue语句

continue 的功能是跳过这次循环, 立即进入下次循环

代码示例: 找到 100 - 200 中所有 3 的倍数

int num = 100;
while (num <= 200) {
if (num % 3 != 0) {
    num++; // 这里的 ++ 不要忘记! 否则会死循环.
    continue;
}
System.out.println("找到了 3 的倍数, 为:" + num);
num++;
}

执行到 continue 语句的时候, 就会立刻进入下次循环(判定循环条件), 从而不会执行到下方的打印语句.

2.2.4for循环*

【基本语法】

for(表达式①;布尔表达式②;表达式③){
表达式④;
}

表达式1: 用于初始化循环变量初始值设置，在循环最开始时执行，且只执行一次

表达式2: 循环条件，满则循环继续，否则循环结束

表达式3: 循环变量更新方式

执行过程：

表达式1只有在刚开始的时候执行一次，之后都不会再执行了。执行完表达式1后，执行表达式2对其进行判断，在执行表达式4后，再执行表达式3对其更新迭代，以此反复进行，直到其不满足循环条件，则循环结束。

【代码示例】：计算 1 - 100 的和

int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println("sum = " + sum);
// 执行结果
5050

【注意事项】 (和while循环类似) 1. 和 if 类似, for 下面的语句可以不写 { } , 但是不写的时候只能支持一条语句. 建议还是加上 { }

2. 和 if 类似, for 后面的 { 建议和 while 写在同一行.

3. 和 if 类似, for 后面不要多写 分号, 否则可能导致循环不能正确执行.

4. 和while循环一样，结束单趟循环用continue，结束整个循环用break

2.2.5do while循环（不推荐用）

【基本语法】

do{
循环语句;
}while(循环条件);

先执行循环语句, 再判定循环条件，循环条件成立则继续执行，否则循环结束。

【注意事项】 1. do while 循环最后的分号不要忘记

2. 一般 do while 很少用到, 更推荐使用 for 和 while.

3.输入输出

3.1输出到控制台

【基本语法】：
 

System.out.println(msg); // 输出一个字符串, 带换行
System.out.print(msg); // 输出一个字符串, 不带换行
System.out.printf(format, msg); // 格式化输出

（1）println 输出的内容自带 \n, print 不带 \n

（2）printf 的格式化输出方式和 C 语言的 printf 是基本一致的

代码示例：

System.out.println("hello world");
int x = 10;
System.out.printf("x = %d\n", x);

3.2从键盘上输入*

使用 Scanner 读取字符串/整数/浮点数，使用Scanner时，得在修饰类前导入util包。

代码示例（一）：

import java.util.Scanner; // 需要导入 util 包

Scanner sc = new Scanner(System.in);
System.out.println("请输入你的姓名：");
String name = sc.nextLine();
System.out.println("请输入你的年龄：");
int age = sc.nextInt();
System.out.println("请输入你的工资：");
float salary = sc.nextFloat();
System.out.println("你的信息如下：");
System.out.println("姓名: "+name+"\n"+"年龄："+age+"\n"+"工资："+salary);
sc.close(); // 注意, 要记得调用关闭方法

// 执行结果
请输入你的姓名：
张三
请输入你的年龄：
18
请输入你的工资：
1000
你的信息如下：
姓名: 张三
年龄：18
工资：1000.0

（二）：使用 Scanner 循环读取 N 个数字，并求取其平均值

Scanner sc = new Scanner(System.in);
int sum = 0;
int num = 0;
while (sc.hasNextInt()) {
    int tmp = sc.nextInt();
    sum += tmp;
    num++;
}
System.out.println("sum = " + sum);
System.out.println("avg = " + sum / num);
sc.close();


// 执行结果
10
40.0
50.5
^Z
sum = 150.5
avg = 30.1

【注意事项】: 当循环输入多个数据的时候, 在IDEA集成开发环境上使用 ctrl + d 来结束输入,ctrl+c是中断程序 (Windows 上使用 ctrl + z, Linux / Mac 上使用 ctrl + d).

---

4.猜数字练习

游戏规则:

系统自动生成一个随机整数(1-100), 然后由用户输入一个猜测的数字. 如果输入的数字比该随机数小, 提示 "低 了", 如果输入的数字比该随机数大, 提示 "高了" , 如果输入的数字和随机数相等, 则提示 "猜对了" .

 代码示例：

 在第35行代码中，new Random（）括号内的数字是使随机数每次都是根据括号的数字来生成的，也就是每次生成的随机数都是固定不变的。

在第36行代码中，如果我们想让随机数控制在39到100这种类型的范围时，可以在随机数范围后加上对应增加的取值，比如改为:int num=random.nextInt(100)+39;