运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

1. 算术运算符

算术运算符是对数值类型的变量进行运算的，在Java程序中使用的非常的多
有小数参与的运算，得到的结果是近似值

  1. 常用的算术运算符
    | 运算符 | 名称 | | —- | —- | | + | 正号 | | - | 负号 | | + | 加 | | - | 减 | | * | 乘 | | / | 除 | | % | 取模（取余） | | ++ | 自增（前）：先运算后取值 | | ++ | 自增（后）：先取值后运算 | | — | 自增（前）：先运算后取值 | | — | 自增（后）：先取值后运算 | | + | 字符串相加 |

  2. 演示运算符的使用

    1. / 运算符的使用 
      1. System.out.println(10 / 4);  // 两个数字都是int类型，输出2
      2. System.out.println(10.0 / 4);  // 最高精度为double类型，输出2.5
      3. double d = 10 / 4;  // 10/4的值仍为int类型，2
      4. System.out.println(d);  // 输出2.0
  1. % 运算符的使用
    公式 a % b = a - a / b * b
    当a是小数时，公式 a % b = a - (int)a / b * b 
    1. System.out.println(10 % 3); // 1
    2. System.out.println(-10 % 3); // -1
    3. System.out.println(10 % -3); // 1
    4. System.out.println(-10 % -3); // -1
    5. System.out.println(-10.5 % -3); // -1.5
  1. ++ 运算符的使用
    • 单独使用 ```java int i = 10; i++; // i = i + 1 ++i; // i = i + 1 System.out.println(“i=” + i); // 12

int i = 66; System.out.println(++i + i); // 67 + 67 = 134

  2.       -  作为表达式使用 
  3.          - 前++：++i 先自增后赋值
  4. ```java
  5. int j = 8;
  6. int k = ++j; // 等价于 j = j + 1; k = j;
  7. System.out.println("j = " + j + "\nk = " + k); // 9  9
  1.      - 后++：i++ 先赋值后自增
  1. int j = 8;
  2. int k = j++; // 等价于 k = j; j = j + 1;
  3. System.out.println("j = " + j + "\nk = " + k);  // 9  8
  1. 算术运算符练习
    1. 题目一 
      1. int i = 1;
      2. i = i++; // 规则使用临时变量：(1)temp = i; (2)i = i + 1; (3)i = temp;
      3. System.out.println(i); // 输出 1
  1. 题目二 
    1. int i = 1;
    2. i = ++i;  // 规则使用临时变量：(2)i = i + 1; (1)temp = i; (3)i = temp;
    3. System.out.println(i);  // 输出 2
  1. 题目三 
    1. int i1 = 10;
    2. int i2 = 20;
    3. int i = i1++;
    4. System.out.print("i = " +i);  // i = 10
    5. System.out.println("i2 = " + i2);  // i2 = 20
    6. i = --i2;
    7. System.out.print("i = " + i);  // i = 19
    8. System.out.println("i2 = " + i2);  // i2 = 19

  1. 题目四

    1. 任意天数转换为xx个星期零x天
    2. 华氏温度转换为摄氏温度 转换公式为：5/9(华氏温度-100) ```java public class Homework03 { // main方法 public static void main(String[] args) { // 1. 任意天数转换为xx个星期零x天 convertDays(59); // 2. 华氏温度转换为摄氏温度 转换公式为：5/9(华氏温度-100) convertTemperature(234.6); } // 创建函数 private static void convertDays(int num) { // 1. 任意天数转换为xx个星期零x天 int week = num / 7; int day = num % 7; String result = String.format(“%d天 为 %d个星期 零 %d 天”, num, week, day); System.out.println(result); } // 创建函数 private static void convertTemperature(Double fa) { // 2. 华氏温度转换为摄氏温度 double ce = 5d / 9d * (fa - 100); // 整数要转换为double类型 System.out.println(String.format(“%.2f 华氏度约等于 %.2f 摄氏度”, fa, ce));

    } } ```

2. 关系运算符

  1. 运算符表
    | 运算符 | 名称 | 范例 | | —- | —- | —- | | == | 相等于 | 8 == 7 | | != | 不等于 | 8 != 7 | | < | 小于 | 8 < 7 | | \> | 大于 | 8 > 7 | | <= | 小于等于 | 8 <= 7 | | >= | 大于等于 | 8 >= 7 | | instanceof | 检查是否是类的对象 | “ABC” instanceof String |

  2. 案例演示 

    1. int a = 9;  // 在正式开发中，不可以使用a，b，a1，b1等作为变量名称
    2. int b = 8;
    3. System.out.println(a > b);
    4. System.out.println(a >= b);
    5. System.out.println(a <= b);
    6. System.out.println(a < b);
    7. System.out.println(a == b);
    8. System.out.println(a != b);
    9. boolean flag = a > b;
    10. System.out.println(flag);
  1. 细节说明
    1. 关系运算符的结果都是boolean型，也就是要么是true，要么是false
    2. 关系运算符组成的表达式，我们称为关系表达式。a > b
    3. 比较运算符"=="不能误写成"="

3. 逻辑运算符

用于连接多个条件（多个关系表达式），最终的结果也是一个boolean值

  1. 两组逻辑运算符
    1. 短路与 &&，短路或 ||，取反 !
    2. 逻辑与 &，逻辑或 |，^ 逻辑异或
  2. 逻辑运算规则
    1. a & b：&叫逻辑与：规则：当a和b同时为true,则结果为true,否则为false
    2. a && b：&&叫短路与：规则：当a和b同时为true,则结果为true,否则为false
    3. a | b：|叫逻辑或，规则：当a和b,有一个为true,则结果为true,否则为false
    4. a || b：||叫短路或，规则：当a和b,有一个为true,则结果为true,否则为false
    5. !a：叫取反，或者非运算。当a为true,则结果为false,当a为false，结果为true
    6. a ^ b：叫逻辑异或，当a和b不同时，则结果为true,否则为false
  3. 逻辑运算表
    第三章 运算符 - 图1

  4. && 和 & 的基本规则
    | 名称 | 语法 | 特点 | | —- | —- | —- | | 短路与 && | 条件1 && 条件2 | 两个条件都为true
    ，结果为true | | 逻辑与 & | 条件1 && 条件2 | 两个条件都为true
    ，结果为true |

  5. && 和 & 的案例演示 

    1. // && 短路与
    2. int age = 50;
    3. if (age > 20 && age < 90) {
    4. System.out.println("ok100"); // ok100
    5. }
    6. // & 逻辑与
    7. age = 50;
    8. if (age > 20 & age < 30) {
    9. System.out.println("ok200"); // 不成立
    10. }
  1. && 和 & 的使用区别
    1. && 短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false，效率高
    2. & 逻辑与：不管第一个条件是否为false，第二个条件都要判断，效率低
    3. 开发中，我们使用的基本是短路与 &&，效率高 ``java // 短路与和逻辑与的区别 // 短路与：如果第一个条件为false，则第二个条件不会判断 int a = 4; int b = 9; if (a < 1 && ++b < 50) { // 第一个条件为false`，++b不会运行 System.out.println(“ok300”); // 不成立 } System.out.println(“a = “ + a + “, b = “ + b); // a = 4, b = 9

// 逻辑与：不管第一个条件是否为false，第二个条件都要判断 a = 4; b = 9; if (a < 1 & ++b < 50) { // 第一个条件为false，++b仍然运行 System.out.println(“ok300”); // 不成立 } System.out.println(“a = “ + a + “, b = “ + b); // a = 4, b = 10

  2. 7.  `||` 和 `|` 的基本规则  
  3. | 名称 | 语法 | 特点 |
  4. | --- | --- | --- |
  5. | 逻辑或 `\\&#124;\\&#124;` | 条件1 &#124;&#124; 条件2 | 只要有一个条件为`true`<br />，结果为`true` |
  6. | 逻辑或 `\\&#124;` | 条件1 &#124;&#124; 条件2 | 只要有一个条件为`true`<br />，结果为`true` |
  8. 8.  `||` 和 `|` 的案例演示 
  9. ```java
  10. // || 短路或
  11. int age = 50;
  12. if (age > 20 || age < 40) { // 满足第一个条件，不满足第二个
  13.     System.out.println("ok100"); // 成立，输出 ok100
  14. }
  15. // | 逻辑或
  16. age = 50;
  17. if (age > 60 | age < 30) { // 两个条件都不成立
  18.     System.out.println("ok200"); // 不成立
  19. }
  1. || 和 | 的使用区别
    1. || 短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高
    2. | 逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
    3. 开发中，我们使用的基本是逻辑与 || ``java // 短路或和逻辑或的区别 // 短路或：如果第一个条件为true，则第二个条件不会判断 int a = 4; int b = 9; if (a > 1 || ++b < 50) { // 第一个条件为true`，++b不会运行 System.out.println(“ok300”); // 成立 System.out.println(“a = “ + a + “, b = “ + b); // a = 4, b = 9

// 逻辑或：不管第一个条件是否为true，第二个条件都要判断 a = 4; b = 9; if (a > 1 | ++b < 50) { // 第一个条件为true，++b仍然运行 System.out.println(“ok300”); // 不成立 } System.out.println(“a = “ + a + “, b = “ + b); // a = 4, b = 10

  2. 10.  `!` 取反的基本规则  
  3. | 名称 | 语法 | 特点 |
  4. | --- | --- | --- |
  5. | `!`<br /> 非(取反) | `!`<br />条件 | 如果条件本身成立，结果为`false`<br />，否则为`true` |
  7. 11.  `!` 案例演示 
  8. ```java
  9. System.out.println(60 > 20); // true
  10. System.out.println(!(60 > 20)); // false

  1. ^ 基本规则
    | 名称 | 语法 | 特点 | | —- | —- | —- | | ^
    逻辑异或 | 条件1 ^
    条件2 | 当条件1与条件2不同时，结果为true |

  2. ^ 案例演示 

    1. boolean b1 = (10 > 1) ^ (3< 5); 
    2. // true ^ true 两边结果相同，返回false
    3. System.out.println("b1 = " + b1); // false
    4. boolean b2 = (10 > 1) ^ (3 > 5);
    5. // true ^ false 两边结果不同，返回true
    6. System.out.println("b2 = " + b2); // true
  1. 课后习题 ```java // 题目 1 // 逻辑与 int x = 5, y = 5; if (x++ == 6 & ++y == 6) { x = 11; } System.out.println(“x = “ + x + “, y = “ + y); // 6, 6 // 短路与 int x = 5, y = 5; if (x++ == 6 && ++y == 6) { x = 11; } System.out.println(“x = “ + x + “, y = “ + y); // 6, 5 // 逻辑或 int x = 5, y = 5; if (x++ == 5 | ++y == 5) { x = 11; } System.out.println(“x = “ + x + “, y = “ + y); // 11, 6 // 短路或 int x = 5, y = 5; if (x++ == 5 || ++y == 5) { x = 11; } System.out.println(“x = “ + x + “, y = “ + y); // 11, 5

// 题目 2 boolean x = true; boolean y = false; short z = 46; if ((z++ == 46) && (y = true)) // z = 47 z++; // z = 48 if ((x = false) || (++z == 49)) // z = 49 z++; // z = 50 System.out.println(“z = “ + z); // 50

  3. <a name="f7a2db44"></a>
  4. ### 4. 赋值运算符
  6. > 赋值运算符就是将某个运算后的值，赋给指定的变量
  9. 1.  赋值运算符的分类 
  10.    1. 基本运算符 `=`
  11.    1. 复合运算符 `+=, -=, /=, %=` 等
  12. 2.  案例演示 
  13. ```java
  14. int n1 = 10;
  15. n1 += 4; // n1 = n1 + 4
  16. System.out.println("n1 = " + n1); // 14
  17. n1 /= 3; // n1 = n1 / 3;
  18. System.out.println("n1 = " + n1); // 4
  1. 赋值运算符的特点
    1. 运算顺序从右往左
    2. 赋值运算符的左边只能是变量，右边可以使变量、表达式、常量值
    3. 复合赋值运算符可以换算为赋值运算符
    4. 复合赋值运算符会进行类型转换

5. 三元运算符

  1. 基本语法：条件表达式 ? 表达式1 : 表达式2;
  2. 运算规则
    1. 如果条件表式为true，运算后的结果是表达式1
    2. 如果表达式为false，运算后的结果是表达式2
  3. 案例演示 
    1. int a = 10;
    2. int b = 99;
    3. int result = a > b ? a++ : b--;
    4. System.out.println("a = " + a); // 10
    5. System.out.println("b = " + b); // 98
    6. System.out.println("result = " + result); // 99
  1. 使用细节
    1. 表达式1和表达式2必须是可以赋给接收变量的类型（或自动转换/强制转换） 
      1. int a = 3;
      2. int b = 8;
      3. int c = a > b ? a : b; // 类型符合，可以运行
      4. int d = a > b ? 1.1 : 2.3; // 编译报错
  1. 三元运算符可以转成if--else语句 
    1. int a = 3;
    2. int b = 8;
    3. int res;
    4. // 三元运算符
    5. res = a > b ? a++ : --b;
    6. // 可以转换为if语句：
    7. if (a > b)
    8. res = a++;
    9. else
    10. res = --b;
  1. 课堂练习 ```java // 求三个数的最大值 int n1 = 35; int n2 = 55; int n3 = 125; int mix1 = n1 > n2 ? n1 : n2; int mix2 = mix1 > n3 ? mix1 : n3; System.out.println(“最大值为：” + mix2); // 125

// 下面是合并写法，不推荐使用 int mix3 = (n1 > n2 ? n1 : n2) > n3 ? (n1 > n2 ? n1 : n2) : n3; int mix4 = n1 > n2 ? (n1 > n3 ? n1 : n3) : (n2 > n3 ? n2 : n3); System.out.println(mix3); // 125 System.out.println(mix4); // 125

  3. <a name="8f66474f"></a>
  4. ### 6. 运算符优先级
  6. 1. 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如下表，上一行运算符总优先于下一行。
  7. 1. 只有单目运算符、赋值运算符是从右向左运算的。
  8. | 优先级 | 运算符 | 关联性 |
  9. | --- | --- | --- |
  10. | 1 | `. () [] {} ; ,` | 从左向右 |
  11. | 2 | `! +(正) -(负) ~ ++ --` | 从右向左 |
  12. | 3 | `* / %` | 从左向右 |
  13. | 4 | `+ -` | 从左向右 |
  14. | 5 | `<< >> >>>` | 从左向右 |
  15. | 6 | `< > <= >= instanceof` | 从左向右 |
  16. | 7 | `== !=` | 从左向右 |
  17. | 8 | `&` | 从左向右 |
  18. | 9 | `^` | 从左向右 |
  19. | 10 | `&#124;` | 从左向右 |
  20. | 11 | `&&` | 从左向右 |
  21. | 12 | `&#124;&#124;` | 从左向右 |
  22. | 13 | `? :` | 从右向左 |
  23. | 14 | `= += -= *= /= &= \\&#124;= ^= ~= «= »= >>>=` | 从右向左 |
  26. 大致可分为几大类
  28. 1. `(), {}` 等
  29. 1. 单目运算
  30. 1. 算术运算符
  31. 1. 位移运算符
  32. 1. 比较运算符
  33. 1. 逻辑运算符
  34. 1. 三元运算符
  35. 1. 赋值运算符
  37. <a name="022e6f69"></a>
  38. ### 7. 标识符命名的规则和规范
  40. 1.  标识符概念 
  41. > 1. Java 对各种变量、方法和类等命名时使用的字符序列成为标识符
  42. > 1. 凡是自己可以起名字的地方都叫标识符
  46. 2.  标识符的命名规则（必须遵守） 
  47.    1. 由26个英文字母大小写，0-9，_ 或 $ 组成
  48.    1. 数字不用于开头
  49.    1. 不可使用关键字和保留字，但能包含关键字和保留字
  50.    1. Java中严格区分大小写，长度无限制
  51.    1. 标识符不能包含空格
  52. 3.  标识符命名规范（建议遵守） 
  53.    1. 包名：多单词组成时所有字母都小写
  54.    1. 类名、接口名：多单词组成时，所有单词的首字母大写（大驼峰）
  55.    1. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写（小驼峰）
  56.    1. 常量名：所有字母都大写。多单此时每个单词用下划线连接
  57. 4.  Java关键字 
  58.    1. 定义：被Java语言赋予了特殊含义，用作专门用途的字符串
  59.    1. 关键字中所有的字母都为小写
  60. 5.  Java保留字 
  61.    - 介绍：现有的Java版本尚未使用，但以后版本可能会作为关键字使用,命名标识符时要避免使用这些保留字
  63. <a name="30b4b312"></a>
  64. ### 8. 键盘输入语句
  66. 1.  在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。需要一个扫描器（对象），就是 `Scanner` 
  67. 1.  步骤<br />1. 导入该类的所在包，`java.util.`<br />2. 创建该类对象（声明变量）<br />3. 调用里面的功能 
  68. 1.  演示 
  69. ```java
  70. // 创建Scanner对象，System.in从键盘输入
  71. Scanner input = new Scanner(System.in);
  72. System.out.println("请输入姓名：");
  73. String name = input.next(); // 接收输入
  74. System.out.println("请输入年龄：");
  75. int age = input.nextInt();
  76. System.out.println("请输入成绩：");
  77. double score = input.nextDouble();
  78. System.out.println("name: " + name);
  79. System.out.println("age: " + age);
  80. System.out.println("score: " + score);

9. 进制

  1. 进制介绍
    1. 二进制：0, 1，满2进1。以0b或0B开头
    2. 十进制：0-9，满10进1
    3. 八进制：0-7，满8进1。以数字0开头
    4. 十六进制：0-9及A(10)-F(15)，满16进1。以0x或0X开头，A-F不区分大小写

  2. 二进制、十进制和十六进制对照表
    | 二进制 | 十进制 | 十六进制 | | —- | —- | —- | | 0000 | 0 | 0 | | 0001 | 1 | 1 | | 0010 | 2 | 2 | | 0011 | 3 | 3 | | 0100 | 4 | 4 | | 0101 | 5 | 5 | | 0110 | 6 | 6 | | 0111 | 7 | 7 | | 1000 | 8 | 8 | | 1001 | 9 | 9 | | 1010 | 10 | A | | 1011 | 11 | B | | 1100 | 12 | C | | 1101 | 13 | D | | 1110 | 14 | E | | 1111 | 15 | F |

  3. 进制的转换

    1. 十进制与其他进制的相互转换
      1. 二进制转十进制
        • 从最低位(右边)开始，将每个位上的数提取出来，乘以2的(位数-1)次方然后求和
        • 第三章 运算符 - 图2
      2. 八进制转十进制
        • 从最低位(右边)开始，将每个位上的数提取出来，乘以8的(位数-1)次方然后求和
        • 第三章 运算符 - 图3
      3. 十六进制转十进制
        • 从最低位(右边)开始，将每个位上的数提取出来，乘以16的(位数-1)次方然后求和
        • 第三章 运算符 - 图4
      4. 十进制转二进制
        • 将该数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制
        • 将 34 转为二进制 
          1. 34 / 2 = 17 ... 0   ↑
          2. 17 / 2 = 8 .... 1   ↑
          3. 8 / 2 = 4 ..... 0   ↑
          4. 4 / 2 = 2 ..... 0   ↑
          5. 2 / 2 = 1 ..... 0   ↑
          6. 1 / 2 = 0 ..... 1   ↑
          7. 由于一个字节占8位，所以要在前面加两个0，`34` 对应的二进制为 0b 0010 0010
  1.      -  由于一个字节占8位，所以要在前面加两个0，`34` 对应的二进制为 `0b 0010 0010` 
  2.   5.  十进制转八进制 
  3.      -  将该数不断除以**8**，直到**商**为**0**为止，然后将每步得到的**余数**倒过来，就是对应的**八进制** 
  4.      -  将 `131` 转为八进制 
  1. 131 / 8 = 16 ... 3   ↑
  2. 16 / 8 = 2 ..... 0   ↑
  3. 2 / 8 = 0 ...... 2   ↑
  1.      -  `131` 对应的八进制为 `0203` 
  2.   6.  十进制转十六进制 
  3.      -  将该数不断除以**16**，直到**商**为**0**为止，然后将每步得到的**余数**倒过来，就是对应的**十六进制** 
  4.      -  将 `237` 转为十六进制 
  1. 237 / 16 = 14 ...13   ↑
  2. 14 / 16 = 0 .....14   ↑
  1.      -  `237` 对应的十六进制为 `0xDE`
  1. 二进制和其他进制的相互转换
    1. 二进制转八进制
      • 从低位开始，将二进制数每3位一组，转成对应的十进制，然后将每步得到的结果倒过来，就是对应的八进制
      • 将 0b 1101 0101 转换为八进制 
        1. 101 = 5;   ↑
        2. 010 = 2;   ↑
        3. 011 = 3;   ↑
  1.      -  `0b 1101 0101` 对应的八进制为 `0325` 
  2.   2.  二进制转十六进制 
  3.      -  从低位开始，将二进制数**每4位**一组，转成对应的**十进制**，然后将每步得到的结果倒过来，就是对应的**八进制** 
  4.      -  将 `0b 1101 0101` 转为十六进制 
  1. 0101 = 1 + 0 + 4 + 8 = 13;
  2. 1101 = 1 + 0 + 4 + 0 = 5;
  1.      -  `0b 1101 0101` 对应的十六进制为 `0x5D` 
  2.   3.  八进制转二进制 
  3.      -  将八进制数**每1位**，转成对应的一个**3位**的二进制数即可 
  4.      -  将 `0237` 转为二进制 
  1. 7 >> 111
  2. 3 >> 011
  3. 2 >> 010
  1.      -  `0237` 对应的二进制为 `0b 1001 1111` 
  2.   4.  八进制转十六进制 
  3.      -  将八进制数**每1位**，转成对应的一个**4位**的二进制数即可 
  4.      -  将 `0x23B` 转为二进制 
  1. B >> 1011
  2. 3 >> 0011
  3. 2 >> 0010
  1.      -  `0x23B` 对应的二进制为 `0b 0010 0011 1011`

10. 二进制在运算中的说明

  1. 二进制是逢2进位的进位制，0、1是基本算符。
  2. 二进制的作用
    • 现代的电子计算机技术全部采用的是二进制，因为它只使用0、1两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制(Binary)数用0和1两个数字及其组合来表示任何数。进位规则是”逢2进1”，数字1在不同的位上代表不同的值，按从右至左的次序，这个值以二倍递增。
  3. 原码、反码、补码（重点 难点）
    1. 二进制的最高位是符号位：0表示正数，1表示负数
    2. 正数的原码、反码、补码都一样
    3. 负数的反码 = 它的原码符号位不变，其他位取反(0->1, 1->0)
    4. 负数的补码 = 它的反码+1，负数的反码 = 负数的补码-1
    5. 0的反码、补码都是0
    6. Java没有无符号数，换言之，Java中的数都是有符号的
    7. 在计算机运算的时候，都是以补码的方式来运算的
    8. 当我们看运算结果的时候，要看它的原码

11. 位运算符

Java中有7个位运算(&, |, ^, ~, >>, <<, >>>)

  1. 按位与 &、按位或 |，按位异或 ^，按位取反~ 的运算规则
    | 位运算符 | 运算规则 | | —- | —- | | 按位与 & | 两位全为1
    ，结果为1
    ，否则为0 | | 按位或 \\ | 两位有一个为1
    ，结果为1
    ，否则为0 | | 按位异或 ^ | 两位一个为0
    ，一个为1
    ，结果为1
    ，否则为0 | | 按位取反 ~ | 0->1
    , 1->0 |

  2. 案例演示 ```java // 1. 第一题：2 & 3 = ? // 1. 先得到2的补码 // 2的原码：00000000 00000000 00000000 00000010 // 2的补码：00000000 00000000 00000000 00000010 // 2. 得到3的补码 // 3的原码：00000000 00000000 00000000 00000011 // 3的补码：00000000 00000000 00000000 00000010 // 3. 按位 & // 运算后补码 // 00000000 00000000 00000000 00000010 // 4. 转为原码 // 00000000 00000000 00000000 00000010 // 5. 转为十进制，结果就是2 System.out.println(2 & 3); // 2

// 2. 第二题：~-2 = ？ // 1. 先得到-2的补码 // -2的原码：10000000 00000000 00000000 00000010 // -2的反码：11111111 11111111 11111111 11111101 // -2的补码：11111111 11111111 11111111 11111110 // 2. 补码运算取反 // 00000000 00000000 00000000 00000001 // 3. 运算后原码： // 00000000 00000000 00000000 00000001 // 4. 转为十进制，结果为 1 System.out.println(~-2); // 1

// 3. 第三题：~2 = ? // 1. 先得到2的补码 // 2的原码：00000000 00000000 00000000 00000010 // 2的补码：00000000 00000000 00000000 00000010 // 2. 补码运算取反 // 11111111 11111111 11111111 11111101 // 3. 计算反码 // 11111111 11111111 11111111 11111100 // 4. 转为原码 // 10000000 00000000 00000000 00000011 // 5. 转为十进制，结果为 -3 System.out.println(~2); // -3

  3. 3.  `>>, <<, >>>` 的运算规则  
  4. | 位运算符 | 运算规则 |
  5. | --- | --- |
  6. | `>>`<br /> 算术右移 | 低位溢出，符号位不变，并用符号位补溢出的高位 |
  7. | `<<`<br /> 算术左移 | 符号位不变，低位补`0` |
  8. | `>>>`<br /> 逻辑右移也叫无符号右移 | 低位溢出，高位补`0` |
  9. | > | 特别说明，没有 `<<<`<br /> 符号 |
  11. 4.  案例演示 
  12. ```java
  13. int a = 1 >> 2; // 0
  14. // 分析
  15. // 1. 得出1的补码
  16. // 00000000 00000000 00000000 00000001
  17. // 2. 算术右移2位 >>
  18. // 00000000 00000000 00000000 00000000
  19. // 本质 1 / 2 / 2
  20. // 3. 转为十进制，结果为0
  22. int b = 1 << 2; // 4
  23. // 分析
  24. // 1. 得出1的补码
  25. // 00000000 00000000 00000000 00000001
  26. // 2. 算术左移2位 <<
  27. // 00000000 00000000 00000000 00000100
  28. // 本质 1 * 2 * 2
  29. // 3. 转为十进制，结果为4
  31. int e = -1 >> 2; // -1
  32. // 1. 原码：10000000 00000000 00000000 00000001
  33. // 2. 反码：11111111 11111111 11111111 11111110
  34. // 3. 补码：11111111 11111111 11111111 11111111
  35. // 4. 右移：11111111 11111111 11111111 11111111
  36. // 5. 反码：11111111 11111111 11111111 11111110
  37. // 6. 原码：10000000 00000000 00000000 00000001
  39. int c = 4 << 3; // 4 * 2 * 2 * 2 = 32
  41. int d = 15 >> 2; // 15 / 2 / 2 = 3
  43. int f = -1 << 2; // -1 * 2 * 2 = -4
  45. int g = -8 >> 5; // -7
  47. System.out.println(a + ", " + b + ", " + c + ", " + d + ", " + e + ", " + f + ", " + g);