2.4 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。
算术运算符 赋值运算符 比较运算符（关系运算符） 逻辑运算符 位运算符 三元运算符

2.4.1 运算符：算术运算符

image.png
算术运算符的注意问题
如果对负数取模，可以把模数负号忽略不记，如：5%-2=1。 但被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。
对于除号“/”，它的整数除和小数除是有区别的：整数之间做除法时，只 保留整数部分而舍弃小数部分。 例如：int x=3510;x=x/1000*1000; x的 结果是？
“+”除字符串相加功能外，还能把非字符串转换成字符串.例如： System.out.println(“5+5=”+5+5); //打印结果是？ 5+5=55
s1++; // 自增1不会改变本身变量的数据类型
s2+=2; // 自增2不会改变本身变量的数据类型

  1. class AriTest {
  2.     public static void main(String[] args) {
  3.         // 除号：/
  4.         int num1 = 12;
  5.         int num2 = 5;
  6.         int result1 = num1 / num2;
  7.         System.out.println(result1); //2  
  9.         int result2 = num1 / num2 * num2;
  10.         System.out.println(result2); //10
  12.         double result3 = num1 / num2;
  13.         System.out.println(result3); //2.0
  15.         double result4 = num1 / num2 + 0.0; 
  16.         System.out.println(result4); // 2.0
  18.         double result5 = num1 / (num2 + 0.0); 
  19.         System.out.println(result5); // 2.4
  21.         double result6 = (double)num1 / num2; 
  22.         System.out.println(result6); // 2.4
  24.         // 取余运算：%
  25.         // 结果的符号与被模数的符号相同
  26.         //开发中经常使用%来判断是否能被除尽
  27.         int m1 = 12;
  28.         int n1 = 5;
  29.         System.out.println("m1 % n1 = " + m1 % n1); //2
  31.         int m2 = -12;
  32.         int n2 = 5;
  33.         System.out.println("m2 % n2 = " + m2 % n2); //-2
  35.         int m3 = 12;
  36.         int n3 = -5;
  37.         System.out.println("m3 % n3 = " + m3 % n3);//2
  39.         int m4 = -12;
  40.         int n4 = -5;
  41.         System.out.println("m4 % n4 = " + m4 % n4);//-2
  43.         //(前)++ : 先自增1再运算
  44.         //(后)++ : 先运算再自增1
  45.         int a1 = 10;
  46.         int b1 = ++a1; 
  47.         System.out.println("a1 = " + a1 + ",b1 = " + b1);// a1 = 11, b1 = 11
  49.         int a2 = 10;
  50.         int b2 = a2++;  
  51.         System.out.println("a2 = " + a2 + ",b2 = " + b2);// a1 = 11, b1 = 10
  53.         // 注意：
  54.         short s1 = 10;
  55.         //s1 = s1 + 1; // 编译失败
  56.         s1 = (short)(s1 + 1); //编译通过
  58.         s1++; // 自增1不会改变本身变量的数据类型
  59.         System.out.println(s1);
  61.         //问题：
  62.         byte b3 = 127;
  63.         b3++;
  64.         System.out.println("b3 = " + b3); //-128
  67.         //(前)-- ：先自减1，后运算
  68.         //(后)-- ：先运算，后自减1
  69.         int a4 = 10;
  70.         int b4 = --a4; 
  71.         System.out.println("a4 = " + a4 + ",b4 = " + b4);// a4 = 9, b4 = 9
  73.         int a5 = 10;
  74.         int b5 = a5--; 
  75.         System.out.println("a5 = " + a5 + ",b5 = " + b5);// a5 = 9, b5 = 10
  77.     }
  78. }

算术运算符练习：

  1. /*
  2. 随意给出一个整数，打印显示它的个位数，十位数，百位数的值。
  3. */
  4. class  AriExer{
  5.     public static void main(String[] args) {
  7.         int num = 563;
  8.         int bai = num / 100;
  9.         int shi = num % 100 / 10; // int shi = num / 10 % 10;
  10.         int ge = num % 10;
  12.         System.out.println("百位为: " + bai);
  13.         System.out.println("十位为: " + shi);
  14.         System.out.println("个位为: " + ge);
  16.     }
  17. }
  1. class SetValueTest {
  2.     public static void main(String[] args) 
  3.     {
  4.         // 赋值符号：=
  5.         int i1 = 10;
  6.         int j1 = 10;
  8.         int i2, j2;
  9.         // 连续赋值
  10.         i2 = j2 = 10;
  12.         //***************************
  13.         int num1 = 10;
  14.         num1 += 2; //num1 = num1 + 2;
  15.         System.out.println(num1); //12
  17.         int num2 = 12;
  18.         num2 %= 5; // num2 = num2 % 5;
  19.         System.out.println(num2); //2
  21.         short s1 = 10;
  22.         //s1 = s1 + 2; // 编译失败，将int转换为short有精读损失
  23.         s1 += 2; // 不会改变变量本身的数据类型
  24.         System.out.println(s1); //12
  26.         // 开发中，如果希望变量实现+2的操作，有几种方法？
  27.         //（前提：int num = 10;)
  28.         // 方式一：num = num + 2
  29.         // 方式二：num += 2;(推荐)
  31.         // 开发中，如果希望变量实现+1的操作，有几种方法？
  32.         //（前提：int num = 10;)
  33.         // 方式一：num = num + 1
  34.         // 方式二：num += 1;
  35.         // 方式二：num ++;(推荐)
  37.         // 练习1
  38.         int i = 1;
  39.         i *= 0.1; //不会改变变量本身的数据类型，截断
  40.         System.out.println(i);// 0
  41.         i++;
  42.         System.out.println(i);// 1
  44.         // 练习2
  45.         int m = 2;
  46.         int n = 3;
  47.         n *= m++; // n = n * m++
  48.         System.out.println("m=" + m); //3
  49.         System.out.println("n=" + n); //6
  51.         // 练习3
  52.         int n1 = 10;
  53.         n1 += (n1++) + (++n1); // n = 10 + 10 + 12
  54.         // (n1++)先运算，此时10参与运算，但n1的值变为11；
  55.         //然后进行+(++n1)，n1先自增变为12，再参与运算
  56.         System.out.println(n1); //32
  57.     }
  58. }

2.4.3 运算符：比较运算符

image.png
运算符之三：比较运算符
== != > < >= <= instanceof
结论：
1. 比较运算符的结果是boolean类型
2. 区分 == 和 =

  1. < >= <=：只能使用在数值类型的数据之间。

  2. == 和 !=：不仅可以使用在数值类型数据之间，还可以使用在其他引用类型变量之间 ```java class { public static void main(String[] args) {

    1.  int i = 10;
    2.  int j = 20;
    4.  System.out.println(i == j); // false
    5.  System.out.println(i = j); // 20，先将j赋值给i，再打印i
    7.  boolean b1 = true;
    8.  boolean b2 = false;
    9.  System.out.println(b2 == b1); // false
    10.  System.out.println(b2 = b1); // true

    } }

  2. <a name="eNL45"></a>
  3. ###  2.4.4 运算符：逻辑运算符  
  4.  &—逻辑与        | —逻辑或         ！—逻辑非       && —短路与         || —短路或             ^ —逻辑异或 
  6. - 逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 & x<6 。 
  7. - “&”和“&&”的区别： 
  8.    - 单&时，左边无论真假，右边都进行运算； 
  9.    - 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。 
  10. - “|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。 
  11. - 异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。 理解：异或，追求的是“异”!  
  12. - 逻辑运算符操作的都是boolean类型的变量，而且结果也是boolean类型。
  14. ![image.png](https://cdn.nlark.com/yuque/0/2022/png/26120819/1650366718044-2f4ef4bb-96c5-4952-a0d8-604bf5de0b6c.png#clientId=ue468b37d-efb6-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=296&id=ua8b7b9c6&margin=%5Bobject%20Object%5D&name=image.png&originHeight=296&originWidth=810&originalType=binary&ratio=1&rotation=0&showTitle=false&size=45939&status=done&style=none&taskId=u758d9b7e-5818-457b-ad11-967932dd1d6&title=&width=810)
  16. ```java
  17. class Test {
  18.     public static void main (String [] args) {
  19.         boolean x=true;
  20.         boolean y=false;
  21.         short z=42;
  22.         //if(y == true)
  23.         if((z++==42)&&(y=true))z++;
  24.         if((x=false) || (++z==45)) z++;
  26.         System. out.println("z="+z); //46
  27.         }
  28. }

2.4.5 运算符：位运算符

image.png
位运算是直接对整数的二进制进行的运算。
向左移动一位，数字2，向左移动两位，数字22
位运算符（了解）
结论：
1. 位运算符操作的都是整型的数据
2.<< : 在一定范围内，每向左移一位，相当于2，向左移二位，相当于2²
>> : 在一定范围内，每向右移一位，相当于/2

面试题：最高效方式计算2*8
2 << 3 或 8 >> 1

  1. class BitTest {
  2.     public static void main(String[] args) {
  3.         int i = 21;
  4.         System.out.println("i << 2: " + (i << 2)); //84 
  5.         System.out.println("i << 3: " + (i << 3)); //168
  6.         System.out.println("i << 26: " + (i << 26)); //1409286144
  7.         System.out.println("i << 27: " + (i << 27)); //-1476395008
  9.         int j = -21;
  10.         System.out.println("j << 2: " + (i << 2)); //-84 
  11.         System.out.println("j << 3: " + (i << 3)); //-168
  12.         System.out.println("j << 26: " + (i << 26)); //-1409286144
  13.         System.out.println("j << 27: " + (i << 27)); //1476395008
  15.         int m = 12;
  16.         int n = 5;
  17.         System.out.println("m & n: " + (m & n)); //4
  18.         System.out.println("m | n: " + (m | n)); //13
  19.         System.out.println("m ^ n: " + (m ^ n)); //9
  21.         // 练习：交换两个变量的值
  22.         int num1 = 10;
  23.         int num2 = 20;
  25.         // 方式1：定义临时变量的方式（推荐）
  26.         int temp = num1;
  27.         num1 = num2;
  28.         num2 = temp;
  29.         System.out.println("num1 = " + num1 + ",num2 = " + num2);
  31.         // 方式2：好处：定义临时变量
  32.         //弊端：(1)相加操作可能超出存储范围 (2) 有局限性，只适用于数值类型
  33.         num1 = num1  + num2;
  34.         num2 = num1  - num2;
  35.         num1 = num1  - num2;
  36.         System.out.println("num1 = " + num1 + ",num2 = " + num2);
  38.         //方式3：使用位运算符
  39.         //有局限性，只适用于数值类型
  40.         num1 = num1 ^ num2;
  41.         num2 = num1 ^ num2;
  42.         num1 = num1 ^ num2;
  43.         System.out.println("num1 = " + num1 + ",num2 = " + num2);
  46.     }
  47. }

image.png
image.png
image.png
image.png
image.png

2.4.6 运算符：三元运算符

三元运算符
1. 结构：(条件表达式)? 表达式1 : 表达式2
2. 说明
(1) 条件表达式的结果为boolean类型
(2) 根据条件表达式真假决定执行哪个表达式。
如果表达式为true，执行表达式1，为false，则执行表达式2
(3) 表达式1和表达式2要求是一致的，即可以转换为一种类型。
(4) 三元运算符可以嵌套使用
三元运算符与if-else的联系与区别：
(1) 凡是可以使用三元运算符的地方，都可以改写为if-else，反之不成立。if后的代码块可有多个语句 。
(2) 如果程序既可以使用三元运算符，又可以使用if-else，优先使用三元运算符。
优点：简洁，执行效率高
(3) 三元运算符要求必须返回一个结果。 

  1. class SanYuanTest {
  2.     public static void main(String[] args) {
  3.         //获取两个整数的较大值
  4.         int m = 12;
  5.         int n = 5;
  7.         int max = (m > n)? m : n;
  8.         System.out.println(max); // 12
  10.         double num = (m > n)? 2 : 1.0;
  11.         System.out.println(num); // 2.0
  13.         //(m > n)? 2 : "n大"; // 编译错误
  14.         //*************************************
  15.         String maxStr1 = (m > n)? "m大" : "n大";
  16.         System.out.println(maxStr1); // m大
  18.         n = 12;
  19.         String maxStr2 = (m > n)? "m大" : ((m == n)?"m和n相等" : "n大");
  20.         System.out.println(maxStr2); // m和n相等
  22.         //*************************
  23.         //获取三个数的最大值
  24.         int n1 = 12;
  25.         int n2 = 30;
  26.         int n3 = -43;
  28.         int max1 = (n1 > n2)? n1 : n2;
  29.         int max2 = (max1 > n3)? max1 : n3;
  30.         System.out.println("三个数中的最大值为：" + max2); // m和n相等
  32.         //不建议
  33.         int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3; // 将max1代入
  34.         System.out.println("三个数中的最大值为：" + max3); 
  36.         // 改写为if-else：
  37.         if(m > n){
  38.             System.out.println(m);
  39.         }else{
  40.             System.out.println(n);
  41.         }
  43.     }
  44. }

2.4.7 运算符的优先级

运算符有不同的优先级，所谓 优先级就是表达式运算中的运算顺序。如右表，上一行运算 符总优先于下一行。 只有单目运算符、三元运算符、 赋值运算符是从右向左运算的。
image.png

第2章 Java基本语法(下)： 程序流程控制

2.5 程序流程控制

• 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
• 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即： 顺序结构；分支结构；循环结构
顺序结构
程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构
根据条件，选择性地执行某段代码。
有if…else和switch-case两种分支语句。
循环结构
根据循环条件，重复性的执行某段代码。
有while、do…while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

2.5.1 顺序结构

Java中定义成员变量时采用合法的前向引用。如：

  1. // 正确形式
  2. public class Test{
  3.     int num1 = 12; 
  4.     int num2 = num1 + 2; 
  5. } 
  6. // 错误形式
  7. public class Test{
  8.     int num2 = num1 + 2； 
  9.         int num1 = 12; 
  10. }

2-5-2 分支语句1： if-else结构

分支结构中的if-else（条件判断结构）

  1. 一、三种结构
  2. 第一种：
  3. if(条件表达式){
  4.     执行表达式1
  5. }
  7. 第二种：二选一
  8. if(条件表达式){
  9.     执行表达式1
  10. }esle{
  11.     }
  13. 第三种：n选一
  14. if(条件表达式){
  15.     执行表达式1
  16. }else if(条件表达式){
  17.     执行表达式2
  18. }else if(条件表达式){
  19.     执行表达式3
  20. }
  21. ...
  22. else{
  23.     执行表达式n
  24. }
  1. class  IfTest{
  2.     public static void main(String[] args) 
  3.     {
  4.         // 举例1
  5.         int heartBeats = 110;
  6.         if(heartBeats < 60 || heartBeats  > 100){
  7.         System.out.println("需要做进一步检查");
  8.         }
  9.         System.out.println("检查结束");
  11.         //举例2
  12.         int age = 23;
  13.         if (age < 18){
  14.             System.out.println("你得认真学习");
  15.         }else{
  16.             System.out.println("你得认真工作");
  17.         }
  19.         //举例3
  20.         if (age < 0){
  21.             System.out.println("您输入的数据非法");
  22.         }else if(age < 18){
  23.             System.out.println("青少年时期");
  24.         }else if(age < 35){
  25.             System.out.println("青壮年时期");
  26.         }else if(age < 60){
  27.             System.out.println("中年时期");
  28.         }else{
  29.             System.out.println("老年时期");
  30.         }
  31.     }
  32. }

分支结构：if-else使用说明

  • 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
  • 语句块只有一条执行语句时，一对{}可以省略，但建议保留
  • if-else语句结构，根据需要可以嵌套使用
  • 当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略
  • 当多个条件是“互斥”关系时，条件判断语句及执行语句间顺序无所谓 当多个条件是“包含”关系时，“小上大下 / 子上父下”

每日一考

  1. “&”和“&&”的异同
  • “&”和“&&”的同：

得到的结果相同。都是表示“且”。左右两侧结果均为true时，得到true。
如果左侧结果是true，都会判断右侧结果。

  • “&”和“&&”的区别：
    • 单&时，左边无论真假，右边都进行运算；
    • 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

2.程序输出

  1. class OperatorTest {
  2.     public static void main(String[] args) {
  3.         boolean x = true;
  4.         boolean y = false;
  5.         short z = 40;
  6.         if ((z++ == 40) && (y = true)) {
  7.             z++;
  8.         }
  9.         if ((x = false) || (++z == 43)) {
  10.             z++;
  11.         }
  12.         System.out.println("z = " + z);
  13.     }
  14. }
  15. //结果为：44

3.定义三个int型变量并赋值，使用三元运算符或者if-else获取这三个数中的较大数的实现

  1. class MaxTest1 {
  2.     public static void main(String[] args) {
  3.         int n1 = 23, n2 = 3, n3 = 5;
  4.         int max1;
  5.         max1 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2): n3;
  6.         System.out.println("max1 = " + max1);
  7.     }
  8. }
  10. class MaxTest2 {
  11.     public static void main(String[] args) {
  12.         int nu1 = 23, nu2 = 3, nu3 = 5;
  13.         int max2;
  14.         if (nu1 >= nu2 && nu1 >= nu3){ 
  15.             max2 = nu1;
  16.         }else if(nu2 >= nu3){
  17.             max2 = nu2;
  18.         }else{
  19.             max2 = nu3;
  20.         }
  21.         System.out.println("max2 = " + max2);
  22.     }
  23. }

4.编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。否则，打印两数的乘积。

  1. class IfTest1 {
  2.     public static void main(String[] args) {
  3.         double num1 = 23.0, num2 = 3.0;
  4.         double result1 = (num1 > 10.0 && num2 <20.0)? num1 + num2 : num1 * num2;
  5.         System.out.println("result1 = " + result1);
  6.     }
  7. }
  9. class IfTest2 {
  10.     public static void main(String[] args) {
  11.         double numb1 = 23.0, numb2 = 3.0;
  12.         if (numb1 > 10.0 && numb2 <20.0){
  13.             double result2 = numb1 + numb2;
  14.             System.out.println("result2 = " + result2);
  15.         }else{
  16.             double result2 = numb1 * numb2;
  17.             System.out.println("result2 = " + result2);
  18.         }
  19.     }
  20. }
  1. 交换两个变量值的代码的实现
  1. class Exchange1 {
  2.     public static void main(String[] args) {
  3.         int i1 = 6;
  4.         int i2 = 3;
  5.         int temp1 = i1;
  6.         i1 = i2;
  7.         i2 = temp1;
  8.         System.out.println("i1 = " + i1 + "," + "i2 = " + i2);
  9.     }
  10. }
  12. class Exchange2 {
  13.     public static void main(String[] args) {
  14.         int i3 = 6;
  15.         int i4 = 3;
  16.         i3 = i3 + i4;
  17.         i4 = i3 - i4;
  18.         i3 = i3 - i4;
  19.         System.out.println("i3 = " + i3 + "," + "i4 = " + i4);
  20.     }
  21. }