一、基本介绍

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

  1. 算术运算符
  2. 赋值运算符
  3. 关系运算符（比较运算符）
  4. 逻辑运算符
  5. 位运算符【需要二进制基础】
  6. 三元运算符

二、算术运算符

2.1 简单介绍

算术运算符是对数值类型的变量进行运算的，在Java程序中使用的非常多。

运算符 运算含义 示例 结果
+ 正号 +7 7
- 负号 b = 11; -b -11
+ 加法 : 相加运算符两侧的值 9+9 18
- 减法 : 左操作数减去右操作数 10-8 2
* 乘法 : 相乘操作符两侧的值 7*8 56
/ 除法 : 左操作数除以右操作数 9/9 1
％ 取模 : 左操作数除以右操作数的余数 11%9 2
++
++		 自增（前）：先运算后取值
自增（后）：先取值后运算		 a=2;b=++a;
a=2;b=a++;		 a=3;b=3
a=3;b=2
—
—		 自减（前）：先运算后取值
自减（后）：先取值后运算		 a=2;b=—a;
a=2;b=a—;		 a=1;b=1;
a=1;b=2
+ 字符串相连 “hxd” + “lsp” “hxdlsp”


2.2 算术运算符细节说明

  1. 在Java中 取模 % 的本质 看一个公式：a % b = a - a / b * b
  2. 自增 ++ 作为独立语句使用，前++和后++都等价于 i = i + 1
    作为表达式使用时：
    前++：先自增后赋值
    后++：先赋值后自增


2.3 案例演示

ArithmeticOperator.java

  1. public class ArithmeticOperator{
  3.     public static void main(String[] args) {
  4.         //演示算术运算符的使用
  6.         // 除号/的使用
  7.         System.out.println(10 / 4);  // 结果是2
  8.         //若精度为double，结果精度也为double
  9.         System.out.println(10.0 / 4);  //结果是2.5 因为10.0
  10.         double d = 10 / 4;  //Java中 10 / 4 = 2 ， 2=>2.0 ，int -> double
  11.         System.out.println(d);
  13.         //取模%（取余）的使用
  14.         //在Java中 %的本质 看一个公式 a % b = a - a / b * b
  15.         //-10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
  16.         //10 % -3 => 10 - 10 / (-3) * (-3) = 10 - 9 = 1 
  17.         System.out.println(10 % 3);   //1
  18.         System.out.println(-10 % 3);   //-1
  19.         System.out.println(10 % -3);   //1
  20.         System.out.println(-10 % -3);   //-1
  22.         //++的使用 --同
  23.         //
  24.         int i = 10;
  25.         i++;  //自增  等价于 i = i + 1;
  26.         System.out.println("i=" + i);   //11
  27.         ++i;  //自增  等价于 i = i + 1;
  28.         System.out.println("i=" + i);   //12
  29.         /*
  30.         作为表达式使用时：
  31.         前++：先自增后赋值
  32.         后++：先赋值后自增
  33.          */
  34.         int j = 8;
  35.         int k = j++;  // 此时 j = 9; k = 8;
  36.         System.out.println("j=" + j);
  37.         System.out.println("k=" + k);
  38.         int l = ++j;  // 此时 j = 10; k = 10; 
  39.         System.out.println("j=" + j);
  40.         System.out.println("l=" + l);
  41.     }
  42. }

2.4 练习题

  1. int i = 1; // i ->1
    i = i++; //规则使用临时变量：(1) temp = i; (2) i = i +1; (3) i = temp;
    System.out.println(i);
    问：结果是多少？为什么？
    回答：1

  2. int i =1;
    i = ++i; //规则使用临时变量：(1) i = i +1; (2) temp = i; (3) i = temp;
    System.out.println(i);
    问：结果是多少？为什么？
    回答：2

  3. 自增自减练习，问输出结果：
    int i1 = 10;
    int i2 = 20;
    int i = i1++; //先赋值再自增
    System.out.print(“i = “ + i); // 10 此时 i1 = 11
    System.out.println(“i2 = “ + i2); // 20
    i = —i2; //先自减再赋值
    System.out.print(“i = “ + i); // 19
    System.out.println(“i2 = “ + i2); // 19

  4. 设计一个程序，将剩余日期转换成XX个星期零XX天
    假设还有59天放假，合XX个星期零XX天？

  5. 定义一个变量保存华氏温度，华氏温度转换摄氏温度的公式为：5/9*（华氏温度-100），请求出华氏温度对应的摄氏温度。[ 234.5 ]

三、关系运算符

3.1 简单介绍

  1. 关系运算符的结果都是 boolean 型，也就是要么是 true ，要么是 false
  2. 关系表达式经常用在 if结构的条件中或循环结构的条件中 | 运算符 | 描述 | 例子 | | —- | —- | —- | | == | 检查如果两个操作数的值是否相等，如果相等则条件为真。 | （8 == 7）为假(非真) | | != | 检查如果两个操作数的值是否相等，如果值不相等则条件为真。 | (8 != 7) 为真 | | > | 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 | （7 > 8）非真 | | < | 检查左操作数的值是否小于右操作数的值，如果是那么条件为真。 | （7 < 8）为真 | | >= | 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 | （7 >= 8）为假 | | <= | 检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。 | （7 <= 8）为真 | | instanceof | 检查是否是类的对象 | “hsp” instanceof String 为真 |

3.2 关系运算符细节说明

  1. 关系运算符的结果都是 boolean 型，也就是要么是 true，要么是 false
  2. 关系运算符组成的表达式，我们称为关系表达式。a > b
  3. 比较运算符 “==”不能误写成 “=”

3.3 案例演示

RelationalOperator.java 

  1. public class RelationalOperator {
  3.     public static void main(String[] args) {
  4.         int a = 9;  //提示：实际开发中，不可以使用a,b,a1,n1...
  5.         int b = 8;
  6.         System.out.println(a > b);   //True
  7.         System.out.println(a >= b);   //T
  8.         System.out.println(a <= b);   //False
  9.         System.out.println(a < b);    //F
  10.         System.out.println(a == b);   //F
  11.         System.out.println(a != b);   //T
  12.         boolean flag = a > b;
  13.         System.out.println("flag = " + flag);
  14.     }
  15. }

四、逻辑运算符

4.1 简单介绍

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

  1. 短路与 &&，短路或 ||，取反 !
  2. 逻辑与 & ，逻辑或 | ，逻辑异或 ^ | a | b | a & b | a && b | a | b | a || b | !a | a ^ b | | —- | —- | —- | —- | —- | —- | —- | —- | | true | true | true | true | true | true | false | false | | true | false | false | false | true | true | false | true | | false | true | false | false | true | true | true | true | | false | false | false | false | false | false | true | false |

4.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

&& 和 & 基本规则

名称 语法 特点
短路与 && 条件1 && 条件2 两个条件都为 true，结果才为 true
逻辑与 & 条件1 & 条件2 两个条件都为 true，结果才为 true

&& 和 & 案例演示 LogicOperator01.java

  1. /**
  2.  * title: && 短路与 和 & 逻辑与 案例演示
  3.  */
  4. public class LogicOperator01 {
  6.     public static void main(String[] args) {
  7.         int age = 50;
  9.         //&& 短路与的使用
  10.         if (age > 20 && age < 90) {          //为真
  11.             System.out.println("ok100");     //可以输出
  12.         }
  13.         if(age > 20 && age < 30) {             //为假
  14.             System.out.println("ok200");     //不能输出
  15.         }
  17.         //& 逻辑与的使用
  18.         if (age > 20 & age < 90) {          //为真
  19.             System.out.println("ok300");     //可以输出
  20.         }
  21.         if(age > 20 & age < 30) {             //为假
  22.             System.out.println("ok400");     //不能输出
  23.         }
  25.         //区别
  26.         int a = 4;
  27.         int b = 9;
  28.         // if (a < 1 && ++b < 50) {
  29.         //     System.out.println("ok500");
  30.         // }
  31.         if (a < 1 & ++b < 50) {
  32.             System.out.println("ok500");
  33.         }
  34.         System.out.println("a=" + a + "b=" + b);
  35.     }
  36. }

&& 和 & 使用区别

  1. && 短路与：如果第一个条件为 false ，则第二个条件不会判断，最终结果为 false，效率高
  2. & 逻辑与：如果第一个条件为 false ，则第二个条件也会判断，效率低
  3. 开发中，我们使用的基本是短路与&&，效率高

|| 和 | 基本规则

名称 语法 特点
短路或 || 条件1 || 条件2 两个条件至少一个为 true ，结果为 true
逻辑或 | 条件1 | 条件2 两个条件至少一个为 true ，结果为 true

|| 和 | 案例演示 LogicOperator02.java

  1. /**
  2.  * title: || 短路或 和 | 逻辑或 案例演示
  3.  */
  4. public class LogicOperator02 {
  6.     public static void main(String[] args) {
  7.         int age = 50;
  9.         //|| 短路或的使用
  10.         if (age > 20 || age < 30) {          //为真
  11.             System.out.println("ok100");     //可以输出
  12.         }
  14.         //| 逻辑或的使用
  15.         if (age > 20 | age < 30) {          //为真
  16.             System.out.println("ok200");     //可以输出
  17.         }
  19.         //区别
  20.         int a = 4;
  21.         int b = 9;
  22.         // if (a < 1 || ++b < 50) {
  23.         //     System.out.println("ok500");
  24.         // }
  25.         if (a < 1 | ++b < 50) {
  26.             System.out.println("ok500");
  27.         }
  28.         System.out.println("a=" + a + "b=" + b);
  29.     }
  30. }

|| 和 | 使用区别

  1. || 短路或：如果第一个条件为 true ，则第二个条件不会判断，最终结果为 true，效率高
  2. | 逻辑或：如果第一个条件为 true ，则第二个条件也会判断，效率低
  3. 开发中，我们使用的基本是短路或 || ，效率高

! 取反 基本规则

名称 语法 特点
! 非（取反） !条件 如果条件本身为 true ,结果为 false

! 取反 案例演示 LogicOperator03.java

  1. /**
  2.  * title: ! 取反 案例演示
  3.  */
  4. public class LogicOperator03 {
  6.     public static void main(String[] args) {
  7.         System.out.println(60 > 20);      // true
  8.         System.out.println(!(60 > 20));   // false
  9.     }
  10. }

^ 逻辑异或 基本规则

名称 语法 特点
^ 逻辑异或 条件1 ^ 条件2 条件1和条件2不同，结果为 true ，
条件1和条件2相同，结果为 false

^ 逻辑异或 案例演示 LogicOperator04.java

  1. /**
  2.  * title: ^ 逻辑异或 案例演示
  3.  */
  4. public class LogicOperator04 {
  6.     public static void main(String[] args) {
  7.         boolean b = (10 > 1) ^ (3 < 5);    //true ^ true
  8.         System.out.println(b);    //输出结果为 false
  9.     }
  10. }

⏱ 小练习 LogicOperatorExercise.java

  1. int x = 5;
    int y = 5;
    if (x++ == 6 & ++y == 6) {
    x = 11;
    }
    System.out.println(“x = “ + x + “,y = “ + y);
    //输出结果为：x = 6,y = 6

  2. int x = 5;
    int y = 5;
    if (x++ == 6 && ++y == 6) { //短路与
    x = 11;
    }
    System.out.println(“x = “ + x + “,y = “ + y);
    // 输出结果为：x = 6，y = 5

  3. int x = 5;
    int y = 5;
    if (x++ == 5 | ++y ==5) { //逻辑或
    x = 11;
    }
    System.out.println(“x = “ + x + “,y = “ + y);
    // 输出结果为：x = 11,y = 6

  4. int x = 5;
    int y = 5;
    if (x++ == 5 || ++y == 5) { //短路或
    x = 11;
    }
    System.out.println(“x = “ + x + “,y = “ + y);
    // 输出结果为：x = 11,y = 5

  5. boolean x = true;
    boolean y = false;
    short z = 46;
    if ((z++ == 46) && (y = true)) z++; //注意：y = true 是赋值语句，不是判等运算
    if ((x = false) || (++z == 49)) z++;
    System.out.println(“z = “ + z);
    // 输出结果为 z = 50

五、赋值运算符

5.1 简单介绍

赋值运算符就是将某个运算后的值，赋给指定的变量。

5.2 赋值运算符的分类

基本赋值运算符：=
复合赋值运算符：+=，-=，*=，/=，%=

a += b; 【等价于 a = a + b;】
a -= b; 【等价于 a = a - b;】
a = b; 【等价于 a = a b;】
a /= b; 【等价于 a = a / b;】
a %= b; 【等价于 a = a % b;】

5.3 赋值运算符特点

  1. 运算顺序从右往左(以“=”为基准) int num = a + b + c;
  2. 赋值运算符的左边 只能是变量，右边 可以是变量、表达式、常量值
    int num = 20; int num2 = 78 * 34 - 10; int num3 = a;
  3. 复合赋值运算符等价于下面的效果
    比如：a += 3; 等价于 a = a + 3;
  4. 复合赋值运算符会进行类型转换
    byte b = 2; b += 3; b++;

5.4 案例演示

AssignOperator.java

  1. /**
  2.  * title:演示赋值运算符的使用
  3.  */
  5. public class AssignOperator {
  7.     public static void main(String[] args) {
  8.         int n1 = 10;
  9.         n1 += 4;   // n1 = n1 + 4;
  10.         System.out.println(n1);   //输出结果为14
  11.         n1 /= 3;   // n1 = n / 3;
  12.         System.out.println(n1);   //输出结果为4
  14.         // 复合赋值运算符会进行类型转换
  15.         byte b = 2;
  16.         b += 3;  // 等价于 b = (byte)(b+3);
  17.         b = b + 3;     // 会报错 
  18.         // 因为 b + 3 会自动转换成 int 类型，而b是byte类型
  19.         // b + 3 赋值给 b ，相当于 int -> byte 
  20.         b++;  // b = (byte)(b + 1);
  21.     }
  22. }

六、三元运算符

6.1 简单介绍

基本语法：条件表达式 ? 表达式1 : 表达式2;

6.2 三元运算符运算规则

  1. 如果条件表达式为 true ，运算后的结果是表达式1；且表达式2不会执行
  2. 如果条件表达式为 false ，运算后的结果是表达式2；且表达式1不会执行

6.3 案例演示

TernaryOperator.java

  1. /**
  2.  * title:三元运算符演示
  3.  */
  4. public class TernaryOperator {
  6.     public static void main(String[] args) {
  7.         int a = 10;
  8.         int b = 99;
  9.         int result = a > b ? a++ : b--;
  10.         System.out.println(result);
  11.         // 解读
  12.         // 1. a > b 为 false
  13.         // 2. 返回 b--，先返回 b 的值,然后再 b - 1
  14.         // 3. 返回的结果为99
  15.         System.out.println(a);
  16.         System.out.println(b);
  17.     }
  18. }

6.4 三元运算符使用细节

  1. 表达式1和表达式2要为可以赋给接受变量的类型（或可以自动转换/强制转换）
  2. 三元运算符可以转成 if - else 语句

⏱小练习：实现三个数的最大值

TernaryOperatorExercise.java

  1. /**
  2.  * title:小练习：实现三个数最大值
  3.  */
  4. public class TernaryOperatorExercise {
  6.     public static void main(String[] args) {
  7.         int a = 15;
  8.         int b = 26;
  9.         int c = 13;
  10.         // int max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
  11.         // 思路
  12.         // 1. 先得到 a 和 b 中的最大值，保存到 mid 中
  13.         // 2. 然后 求出 mid 和 c 中的最大值，保存到 max 中
  14.         int mid = a > b ? a : b;
  15.         int max = mid > c ? mid : c;
  16.         System.out.println(max);
  17.     }
  18. }

七、运算符优先级

7.1 优先级规则

  1. 运算符有不同的优先级，所谓优先级就是表达式运算的运算顺序，如下表，上一行的运算符总优先于下一行
  2. 只有单目运算符、赋值运算符是从右向左运算的 | | . () {} ; , | | —- | —- | | R —> L | ++ — ~ !(data type) | | L —> R | / % | | L —> R | + - | | L —> R | << >> >>> 位移 | | L —> R | < > <= >= instanceof | | L —> R | == != | | L —> R | & | | L —> R | ^ | | L —> R | | | | L —> R | && | | L —> R | || | | L —> R | ? : | | R —> L | = = /= %= | | | += -= <<= >>= | | | >>>= &= ^= |= |

7.2 梳理小结（优先高到低）

  1. () {} 等
  2. 单目运算 ++ — 等
  3. 算术运算符 * / + - 等
  4. 位移运算符
  5. 比较运算符
  6. 逻辑运算符
  7. 三元运算符
  8. 赋值运算符

八、标识符的命名规则和规范

8.1 标识符概念

  1. Java对各种变量、方法和类等命名时使用的字符序列成为标识符
  2. 凡是自己可以起名字的地方都叫标识符 int num1 = 90;

8.2 标识符的命名规则（必须遵守）

  1. 由26个英文字母大小写，数字0~9，_ 或 $ 组成
  2. 数字不可以开头
  3. 不可以使用关键字和保留字，但能包含关键字和保留字
  4. Java中严格区分大小写，长度无限制
  5. 标识符不能包含空格

⏱ 小练习：判断下面变量名是否正确

  1. hsp
  2. hsp12
  3. 1hsp
  4. h-s
  5. x h
  6. h$4
  7. class
  8. int
  9. double
  10. public
  11. static
  12. goto
  13. stu_name

答案：

  1. 正确
  2. 正确
  3. 错误 // 数字不可以开头
  4. 错误 // 不能包含 -
  5. 错误 // 不能包含空格
  6. 正确
  7. 错误 // class 是关键字
  8. 错误 // int 是关键字
  9. 错误 // double 是关键字
  10. 错误 // public 是关键字
  11. 错误 // static 是关键字
  12. 错误 // goto 是保留字
  13. 正确

8.3 标识符的命名规范【更加专业】

  1. 包名：多单词组成时所有字母都小写：aaa.bbb.ccc // 比如：com.hsp.crm
  2. 类名、接口名：多单词组成时，所有单词的 首字母大写：XxxYyyZzz
    比如：TankShotGame
  3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
    比如：tankShotGame
  4. 常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
    比如：定义一个所得税率 TAX_RATE
  5. 后面我们学习到 类，包，接口，等时，我们命名的规范要这样遵守，更加详细的看文档。

8.4 关键字与保留字

关键字的定义和特点
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有的字母都为小写

用于定义数据类型的关键字
class interface enum byte short
int long float double char
boolean void
用于定义数据类型值的关键字
true false null
用于定义流程控制的关键字
if else switch case default
while do for break continue
return

保留字的特点
现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字

byValue cast future generic
inner operator outer rest
var goto const

九、键盘输入语句

9.1 简单介绍

在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来实现。
需要一个扫描器（对象）：Scanner

9.2 使用步骤

  1. 导入该类的所在包，java.util.*
  2. 创建该类对象（声明变量）
  3. 调用里面的功能

9.3 案例演示

Input.java

  1. /**
  2.  * title:接收用户键盘输入案例演示
  3.  */
  5. // 步骤
  6. // Scanner类 表示 简单文本扫描器，在java.util下
  7. // 1.引入（导入） Scanner类所在的包
  8. import java.util.Scanner;  //表示把 java.util 下的 Scanner类 导入
  9. public class Input {
  11.     public static void main(String[] args) {
  12.         // 2.创建Scanner对象,new:创建一个对象
  13.         Scanner myScanner = new Scanner(System.in);
  14.         // 3.接收用户输入，使用相关的方法
  15.         System.out.println("请输入名字");
  16.         // 当程序执行到 next 方法时，会等待用户输入
  17.         String name = myScanner.next();  //接收用户输入字符串
  18.         System.out.println("请输入年龄");
  19.         int age = myScanner.nextInt();  //接收用户输入int
  20.         System.out.println("请输入薪水");
  21.         double salary = myScanner.nextDouble();  //接收用户输入double
  22.         System.out.println("姓名：" + name + "\t年龄：" + age + "\t薪水：" + salary);
  23.     }
  24. }

十、进制

10.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 不区分大小写

10.2 案例演示

BinaryTest.java

  1. /**
  2.  * title:演示进制
  3.  */
  4. public class BinaryTest {
  6.     public static void main(String[] args) {
  7.         int n1 = 0b1010;  //二进制
  8.         int n2 = 1010;  //十进制
  9.         int n3 = 01010;  //八进制
  10.         int n4 = 0x10101;  //十六进制
  11.         System.out.println("n1 = " + n1);
  12.         System.out.println("n2 = " + n2);
  13.         System.out.println("n3 = " + n3);
  14.         System.out.println("n4 = " + n4);
  15.     }
  16. }

进制的图示 (满 进)

十进制 十六进制 八进制 二进制
0 0 0 0
1 1 1 1
2 2 2 10
3 3 3 11
4 4 4 100
5 5 5 101
6 6 6 110
7 7 7 111
8 8 10 1000
9 9 11 1001
10 A 12 1010
11 B 13 1011
12 C 14 1100
13 D 15 1101
14 E 16 1110
15 F 17 1111
16 10 20 10000
17 11 21 10001

10.3 进制的转换（基本功）

第一组：

  1. 二进制转十进制
  2. 八进制转十进制
  3. 十六进制转十进制

第二组：

  1. 十进制转二进制
  2. 十进制转八进制
  3. 十进制转十六进制

第三组：

  1. 二进制转八进制
  2. 二进制转十六进制

第四组：

  1. 八进制转二进制
  2. 十六进制转二进制

二进制转十进制示例
规则：从最低为（右边）开始，将每个位上的数提取出来，乘以2的（位数 - 1）次方，然后求和
案例：请将 0B1011 转成十进制的数

0b1011 = 1 23 + 0 22 + 1 21 + 1 20 = 11

八进制转十进制示例
规则：从最低为（右边）开始，将每个位上的数提取出来，乘以8的（位数 - 1）次方，然后求和
案例：请将 0234 转成十进制的数

0234 = 2 82 + 3 81 + 4 * 80 = 128 + 24 + 4 = 156

十六进制转十进制示例
规则：从最低为（右边）开始，将每个位上的数提取出来，乘以16的（位数 - 1）次方，然后求和
案例：请将 0x23A 转成十进制的数

0x23A = 2 162 + 3 161 + 10 * 160 = 512 + 48 + 10 = 570

十进制转二进制
规则：将该数不断除以2，知道商为0为止，然后将每步得到的余数倒过来，就是对应的二进制
案例：请将 173 转成二进制的数
Java基础：运算符 - 图1
173 = 0B10101101

十进制转八进制
规则：将该数不断除以8，知道商为0为止，然后将每步得到的余数倒过来，就是对应的八进制
案例：请将 167 转成八进制的数
Java基础：运算符 - 图2
167 = 0247

十进制转十六进制
规则：将该数不断除以16，知道商为0为止，然后将每步得到的余数倒过来，就是对应的十六进制
案例：请将 4877 转成十六进制的数
image.png
4877 = 0x130D

⏱ 小练习 (一定动手做，并验证)
123 转成 二进制 => ?
678 转成 八进制 => ?
8912 转成 十六进制 => ?

二进制转八进制
规则：从低位开始，将二进制数每三位一组，转成对应的八进制数即可
案例：将 0b11010101 转成八进制

0b11010101 => 0325

二进制转十六进制
规则：从低位开始，将二进制数每四位一组，转成对应的十六进制数即可
案例：将0b11010101 转成十六进制

0b11010101 => 0xD5

⏱ 小练习
0b11100101 转成八进制
0b1110010110 转成十六进制

八进制转二进制
规则：将八进制的每一位，转成对应的一个 3 位的二进制数即可
案例：将 0237 转成二进制数

0237 => 0b10011111

十六进制转二进制
规则：将八进制的每一位，转成对应的一个 4 位的二进制数即可
案例：将 0x23B 转成二进制数 11

0x23B => 0b001000111011

⏱ 小练习
01230 转成二进制
0xAB29 转成二进制

十一、位运算

  1. 请看下面的代码段，回答a，b，c，d，e 结果是多少？

    1. /**
    2. * title:位运算思考题
    3. */
    4. public class BinaryTest {
    6.  public static void main(String[] args) {
    7.      int a = 1 >> 2;  // 1 向右位移 2 位
    8.      int b = -1 >> 2;
    9.      int c = 1 << 2;
    10.      int d = -1 << 2;
    11.      int e = 3 >>> 2;  //算术右移
    12.      //a,b,c,d,e 结果是多少？
    13.      System.out.println("a = " + a);
    14.      System.out.println("b = " + b);
    15.      System.out.println("c = " + c);
    16.      System.out.println("d = " + d);
    17.      System.out.println("e = " + e);
    18.  }
    19. }

  2. 请回答在Java中，下面表达式的运算结果是：（位操作）

~ 2 = ？ //按位取反
2 & 3 = ？ //2 按位与 3
2 | 3 = ？ //2 按位或 3
~ -5 = ？
13 & 7 = ？
5 | 4 = ？
-3 ^ 3 = ？ //按位异或

11.1 二进制在运算中的说明

  1. 二进制是逢 2 进位的进位制，0、1是基本算符
  2. 现代电子计算机技术全部采用的是二进制，因为它使用0、1两个数字符号，非常简单方便，易于用电子方式实现。计算机内部处理的信息，都是采用二进制数来表示的。二进制（Binary）数用 0 和 1 两个数字及其组合来表示任何数。进位规则是“逢 2 进 1 ”数字1在不同的位上表示不同的值，按从右至左的次序，这个值以二倍递增。

11.2 原码、反码、补码 【重点、难点】

对有符号的而言：

  1. 二进制的最高位是符号位：0表示正数，1表示负数（口诀：0 -> 0 , 1 -> -）
  2. 正数的原码，反码，补码都一样（三码合一）
  3. 负数的反码 = 它的原码符号位不变，其他位取反（0 -> 1 1 -> 0）
  4. 负数的补码 = 它的反码 + 1 ，同样的，负数的反码 = 负数的补码 - 1
  5. 0 的反码，补码都是 0
  6. Java没有无符号数，换言之，Java中所有的数都是有符号的
  7. 在计算机运行的时候，都是以补码的方式来运算的
  8. 当我们看运算结果的时候，要看它的原码
  9. JVM 按32位二进制运算

11.3 位运算符简单介绍

Java中有 7 个位运算（& 、| 、^ 、~ 、>> 、<< 、>>>）
分别是 按位与&、按位或 |、按位异或 ^ ，按位取反 ~，算术右移 >>，算术左移 <<，逻辑右移 >>>
特别说明：没有 <<< 符号

运算规则

按位与 & 两位全为1，结果为1，否则为0
按位或 | 两位有一个为1，结果为1，否则为0
按位异或 ^ 两位一个为0，一个为1，结果为1，相同为0
按位取反 ~ 0 -> 1 , 1->0
算术右移 >> 低位溢出，符号位不变，并用符号位补溢出的高位
1 >> 2 本质 1 / 2 / 2 = 0
算术左移 << 符号位不变，低位补 0
1 << 2 本质 1 2 2 = 4
4 << 3 本质 4 2 2 * 2 = 32
逻辑右移 >>>
无符号右移		 低位溢出，高位补 0

比如： 2 & 3 = ？，~ -2 = ？，~ 2 = ？， 2 | 3 = ？，2 ^ 3 = ？
int a = 1 >> 2;
int c = 1 << 2;

  1. /**
  2.  * title:位运算思考题
  3.  */
  4. public class BitOperator {
  6.     public static void main(String[] args) {
  7.         //位运算
  8.         System.out.println(2 & 3);
  9.         //推导过程
  10.         //1.先得到 2 的补码 => 2的原码 00000000 00000000 00000010
  11.         //   2的补码 00000000 00000000 00000000 00000010
  12.         //2.得到 3 的补码 => 3的原码 00000000 00000000 00000011
  13.         //   3的补码 00000000 00000000 00000000 00000011
  14.         //3.按位&
  15.         //   00000000 00000000 00000000 00000010
  16.         //   00000000 00000000 00000000 00000011
  17.         //   00000000 00000000 00000000 00000010   & 运算后的补码
  18.         //4. 运算后补码的原码
  19.         //     00000000 00000000 00000000 00000010
  20.         //     所以结果是 2
  22.         System.out.println(~ -2);
  23.         //推导过程
  24.         //1. -2原码 10000000 00000000 00000000 00000010
  25.         //     -2反码 11111111 11111111 11111111 11111101
  26.         //     -2补码 11111111 11111111 11111111 11111110
  27.         //2. ~操作  00000000 00000000 00000000 00000001  运算后的补码
  28.         //3. 运算后补码的原码
  29.         //            00000000 00000000 00000000 00000001
  30.         // 所以结果是1
  32.         System.out.println(2 | 3);
  33.         // 2补码 00000000 00000000 00000000 00000010
  34.         // 3补码 00000000 00000000 00000000 00000011
  35.         // |操作 00000000 00000000 00000000 00000011  运算后的补码
  36.         // 正数原码同补码 ，所以结果是3
  38.         System.out.println(~ 2);
  39.         // 2补码 00000000 00000000 00000000 00000010
  40.         // ~操作 11111111 11111111 11111111 11111101  运算后的补码
  41.         // 先求反码 11111111 11111111 11111111 11111100
  42.         // 原码 10000000 00000000 00000000 00000011
  43.         // 所以结果为 -3 
  45.         System.out.println(2 ^ 3);
  46.         // 2补码 00000000 00000000 00000000 00000010
  47.         // 3补码 00000000 00000000 00000000 00000011
  48.         // ^运算 00000000 00000000 00000000 00000001  运算后的补码
  49.         // 结果为正 原码同补码 所以结果为1    
  50.     }
  51. }

⏱ 小练习

  1. 请看下面的代码段，回答a，b，c，d，e 结果是多少？

    1. /**
    2. * title:位运算思考题
    3. */
    4. public class BinaryTest {
    6.  public static void main(String[] args) {
    7.      int a = 1 >> 2;  // 1 算术右移 2 位
    8.      int b = -1 >> 2;
    9.      int c = 1 << 2;  // 算术左移
    10.      int d = -1 << 2;
    11.      int e = 3 >>> 2;  // 无符号右移
    12.      //a,b,c,d,e 结果是多少？
    13.      System.out.println("a = " + a);
    14.      System.out.println("b = " + b);
    15.      System.out.println("c = " + c);
    16.      System.out.println("d = " + d);
    17.      System.out.println("e = " + e);
    18.  }
    19. }

  2. 请回答在Java中，下面表达式的运算结果是：（位操作）

~ 2 = ？ //按位取反
2 & 3 = ？ //2 按位与 3
2 | 3 = ？ //2 按位或 3
~ -5 = ？
13 & 7 = ？
5 | 4 = ？
-3 ^ 3 = ？ //按位异或

十二、本章作业

  1. 计算下面表达式的结果
    10 / 3 = ? 10 / 5 = ? 10 % 2 = ? -10.5 % 3 = ?

  2. 试说出下面代码的结果
    int i = 66;
    System.out.println(++i+i);

  3. 在Java中，以下赋值语句正确的是
    (A) int num1 = (int)”18”; // 错误 应该 Integer.parseInt(“18”);
    (B) int num2 = 18.0; 0
    (C) double num3 = 3d; // 正确，d表示3是double类型
    (D) double num4 = 8; 1
    (E) int i = 48; char ch = i + 1; 0
    (F) byte b = 19; short s = b + 2; 0

  4. 试写出将 String 转成 double 类型的语句，以及将 char 类型转成 String 的语句，举例说明即可
    String str = “18.8”;
    double d1 = Double.parseDouble(str);
    char ch = ‘韩’;
    String str2 = c1 + “”;

学习参考（致谢）：

  1. B站 @程序员鱼皮 Java学习一条龙
  2. B站 @韩顺平 零基础30天学会Java