3.Java 运算符（算术运算符、赋值运算符、逻辑运算符、关系运算符、三元运算符、标识符、键盘输入、进制、原码反码补码、位运算符、运算符优先级）

标签：11111111 Java 00000000 补码 System 运算符 原码 out

一、算术运算符

1、基本介绍

运算符	说明
+	正号
-	负号

运算符	说明
+	加
-	减
*	乘
/	除
%	取模（取余）

运算符	说明	示例	结果
++	自增（前），先运算后取值	a = 2; b = ++a;	a = 3; b = 3;
++	自增（后），先取值后运算	a = 2; b = a++;	a = 3; b = 2;
–	自减（前），先运算后取值	a = 2; b = --a;	a = 1; b = 1;
–	自减（后），先取值后运算	a = 2; b = a–;	a = 1; b = 2;

运算符	说明	示例	结果
+	字符串相加	“Hello” + “World”	“HelloWorld”

2、注意事项

除号（/）

• 整数相除，只保留整数部分，舍弃小数部分

取模（%）

• a % b 等价于 a - a / b * b（结果的符号同 a）

自增（++）

1. a = b++ 等价于 a = b

2. a = ++b 等价于 a = (b + 1)

自减（–）

1. a = b-- 等价于 a = b

2. a = --b 等价于 a = (b - 1)

---

二、赋值运算符

1、基本介绍

• 基本赋值运算符

运算符	说明	示例
=	简单的赋值运算符	-

• 复合赋值运算符

运算符	说明	示例
+=	加和赋值操作符	C += A 等价于 C = C + A
-=	减和喊值操作符	C -= A 等价于 C = C - A
*=	乘和赋值操作符	C *= A 等价于 C = C * A
/=	除和赋值操作符	C /= A 等价于 C = C / A
%=	取模和赋值操作符	C %= A 等价于 C = C % A

运算符	说明	示例
<<=	左移位赋值运算符	C <<= 2 等价于 C = C << 2
>>=	右移位赋值运算符	C >>= 2 等价于 C = C >> 2
&=	按位与赋值运算符	C &= 2 等价于 C = C & 2
|=	按位或赋值运算符	C |= 2 等价于 C = C | 2
^=	按位异或赋值运算符	C ^= 2 等价于 C = C ^ 2

2、注意事项

• 复合赋值运算符会进行类型转换，byte b = 1; b += 1; 等价于 b = (byte) (b + 1);

---

三、逻辑运算符

1、基本介绍

运算符	说明
&	逻辑与，全为 true 时，结果为 true，否则为 false
|	逻辑或，全为 false 时，结果为 false，否则为 true
&&	短路与，全为 true 时，结果为 true，否则为 false
||	短路或，全为 false 时，结果为 false，否则为 true
!	逻辑非，a 为 true 时，结果为 false，a 为 false 时，结果为 true
^	逻辑异或，a 与 b 相同时，结果为 false，a 与 b 不同时，结果为 true

2、注意事项

& 对比 &&

1. a & b，计算 a 与 b

2. a && b，如果 a 为 false，则不计算 b

| 对比 ||

1. a | b，计算 a 与 b

2. a || b，如果 a 为 true，则不计算 b

3、示例实操

a	b	-	a & b	a | b	a && b	a || b	!a	a^b
true	true	-	true	true	true	true	false	false
true	false	-	false	true	false	true	false	true
false	true	-	false	true	false	true	true	true
false	false	-	false	false	false	false	true	false

---

四、关系运算符

运算符	说明
==	等于
!=	不等于
>	大于
<	小于
>=	大于等于
<=	小于等于

运算符	说明	示例	结果
instanceof	检查是否是指定类的对象	“ABC” instanceof String	true

---

五、三元运算符

【条件表达式】 ? 【表达式 1】 : 【表达式 2】

1. 条件表达式为 true 时，执行表达式 1

2. 条件表达式为 false 时，执行表达式 2

• 口诀：一真二假

---

六、标识符

1、概述

• Java 对各种变量、方法、类等命名时使用的字符序列称为标识符

2、命名规则

（1）基本介绍

1. 标识符的组成：26 个英文字母（大小写）、数字 0 - 9、下划线（_）、美元符号（$）

2. 数字不可以开头

3. 不可以使用关键字和保留字，但能包含关键字和保留字

4. 严格区分大小写

5. 不能包含空格

（2）关键字

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

byValue、cast、future、generic、inner、operator、outer、rest、var、goto、const

（3）关键字

• 关键字被 Java 赋予了特殊含义，其中，关键字的所有字母都为小写

1. 用于定义数据类型的关键字

class、interface、enum
byte、int、long、float、doublechar、boolean、void

2. 用于定义数据类型值的关键字

true、false、null

3. 用于定义流程控制的关键字

if、else
switch、case、default
while、do
for、break、continue
return

4. 用于定义访问权限修饰符的关键字

private、protected、public

5. 用于定义类、函数、变量修饰符的关键字

abstract、final、static、synchronized

6. 用于定义类与类之间关系的关键字

extends、implements

7. 用于定义创建实例、引用实例、判断实例的关键字

new、this、super、instanceof

8. 用于异常处理的关键字

try、catch、finally
throw、throws

9. 用于包的关键字

package、import

10. 其他修饰符关键字

native、strictfp、transient、volatile、assert

3、命名规范

1. 包命：多单词组成时，所有字母都小写

2. 类名、接口名：多单词组成时，所有单词的首字母大写

3. 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始首字母大写

4. 常量名：所有字母都大写，多单词组成时，每个单词用下划线（_）连接

---

七、键盘输入

1、基本介绍

• 使用键盘输入

1. 导入 Scanner 类

import java.util.Scanner;

2. 创建 Scanner 对象

Scanner myScanner = new Scanner(System.in);

3. 调用方法，获取键盘输入

String str = myScanner.next();

2、常用方法

方法	说明
nextInt	获取用户输入的整数
nextDouble	获取用户输入的小数
next	获取用户输入的字符串

3、基本使用

• ScannerDemo 类

package com.sunke.scanner;

import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner myScanner = new Scanner(System.in);
        System.out.print("请输入内容：");
        String str = myScanner.next();
        System.out.println("你输入的内容是：" + str);
    }
}

• 输出结果

请输入内容：HelloWorld
你输入的内容是：HelloWorld

---

八、进制

1、基本介绍

进制	范围	说明
二进制	0 ~ 1，满 2 进 1	以 0b / 0B 开头
八进制	0 ~ 8，满 8 进 1	以 0 开头
十进制	0 ~ 9，满 10 进 1	-
十六进制	0 ~ 9 及 A ~ F（此处 A ~ F 不区分大小写），满 16 进 1	以 0x / 0X 开头

十进制（DEC）	十六进制（HEX）	八进制（OCT）	二进制（BIN）
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

2、进制的转换

（1）转十进制

二进制转十进制

• 从最低位（右边）开始，将每个位上的数乘以 2 的 【位数 - 1】 次方，然后求和

0b1010 -> (1 * 2^3) + (0 * 2^2) + (1 * 2^1) + (0 * 2^0) -> 10

八进制转十进制

• 从最低位（右边）开始，将每个位上的数乘以 8 的 【位数 - 1】 次方，然后求和

0144 -> (1 * 8^2) + (4 * 8^1) + (4 * 8^0) -> 100

十六进制转十进制

• 从最低位（右边）开始，将每个位上的数乘以 16 的 【位数 - 1】 次方，然后求和

0x64 -> (6 * 16^1) + (4 * 16^0) -> 100

（2）转二进制

八进制转二进制

• 将每位上的数转换为一个三位的二进制数

0237 -> 02(010)3(011)7(111) -> 0x10011111

十进制转二进制

• 将该十进制数不断除以 2，直到商 0 为止，然后将每步得到的余数倒序拼接得到二进制数

34 -> 0b100010

34 / 2 = 17 ...... 0
17 / 2 = 8 ...... 1
8 / 2 = 4 ...... 0
4 / 2 = 2 ...... 0
2 / 2 = 1 ...... 0
1 / 2 = 0 ...... 1

十六进制转二进制

• 将每个位上的数转换为一个四位的二进制数

0x15 -> 0x1(0001)5(0101) -> 0b10101

（3）转八进制

二进制转八进制

• 从最低位（右边）开始，每三位一组转成对应的八进制数

0b11010101 -> 0b11(3)010(2)101(5) -> 0325

十进制转八进制

• 将该十进制数不断除以 8，直到商 0 为止，然后将每步得到的余数倒序拼接得到八进制数

34 -> 042

34 / 8 = 4 ...... 2
4 / 8 = 0 ...... 4

十六进制转八进制

1. 十六进制 -> 二进制 -> 八进制

2. 十六进制 -> 十进制 -> 八进制

（4）转十六进制

二进制转十六进制

• 从最低位（右边）开始，每四位一组转成对应的十六进制数

0b11010101 -> 0b1101(D)0101(5) -> 0xD5

八进制转十六进制

1. 八进制 -> 二进制 -> 十六进制

2. 八进制 -> 十进制 -> 十六进制

十进制转十六进制

• 将该十进制数不断除以 16，直到商 0 为止，然后将每步得到的余数倒序拼接得到十六进制数

34 -> 0x22

34 / 16 = 2 ...... 2
2 / 16 = 2 ...... 2

3、Java 进制转换

（1）基本介绍

1. 数值转字符串

方法	说明
String toBinaryString(int i)	将数值转换为二进制字符串
String toOctalString(int i)	将数值转换为八进制字符串
String toHexString(int i)	将数值转换为十六进制字符串
String toString(int i, int radix)	将数值转换为指定进制字符串

2. 字符串转数值

方法	说明
int parseInt(String s, int radix)	将指定进制的字符串转换为数值
Integer valueOf(String s, int radix)	将指定进制的字符串转换为数值

（2）基本使用

• DecChange 类

package com.sunke.dec;

public class DecChange {
    public static void main(String[] args) {
        System.out.println(Integer.toBinaryString(100));
        System.out.println(Integer.toOctalString(100));
        System.out.println(Integer.toHexString(100));

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

        System.out.println(Integer.toString(100, 2));
        System.out.println(Integer.toString(100, 4));
        System.out.println(Integer.toString(100, 16));

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

        System.out.println(Integer.parseInt("1100100", 2));
        System.out.println(Integer.parseInt("144", 8));
        System.out.println(Integer.parseInt("64", 16));

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

        System.out.println(Integer.valueOf("1100100", 2));
        System.out.println(Integer.valueOf("144", 8));
        System.out.println(Integer.valueOf("64", 16));
    }
}

• 输出结果

1100100
144
64
------------
1100100
1210
64
------------
100
100
100
------------
100
100
100

---

九、原码、反码、补码

1. 二进制的最高位是符号位：0 表示正数，1 表示负数

2. 正数和 0 的原码、反码、补码一致（三码合一）

3. 负数的反码 = 原码符号位不变，其他位取反（0 转换成 1，1 转换成 0）

4. 负数的补码 = 反码 + 1，负数的反码 = 补码 - 1

5. 计算机以补码的方式运算

6. 查看运算结果时看原码

---

十、位运算符

1、基本介绍

运算符	说明
&	按位与，两位全为 1，结果为 1，否则为 0
|	按位或，两位有一位为 1，结果为 1，否则为 0
^	按位异或，两位一位为 0，一位为 1，结果为 1，否则为 0
~	按位取反，0 转换成 1，1 转换成 0
>>	算术右移，低位溢出，符号位不变，并用符号位填补溢出的高位
<<	算术左移，符号位不变，低位填补 0
>>>	逻辑右移（无符号右移），低位溢出，高位填补 0

2、注意事项

1. A >> B，等价于 A / 2^B

2. A << B，等价于 A * 2^B

• 不存在逻辑左移运算符（<<<）

3、基本使用

package com.sunke.bit;

public class BitOperationDemo {
    public static void main(String[] args) {
        // 1、得到 2 的补码（正数，三码合一）：00000000 00000000 00000000 00000010
        // 2、得到 3 的补码（正数，三码合一）：00000000 00000000 00000000 00000011
        // 3、进行 2 & 3 操作：00000000 00000000 00000000 00000010
        // 4、得到结果（补码）的原码（正数，三码合一）：00000000 00000000 00000000 00000010 -> 2
        System.out.println(2 & 3);

        // 1、得到 -2 的补码（负数）
        //      （1）得到 -2 的原码：10000000 00000000 00000000 00000010
        //      （2）得到 -2 的反码：11111111 11111111 11111111 11111101
        //      （3）得到 -2 的补码：11111111 11111111 11111111 11111110
        // 2、进行 ~-2 操作：00000000 00000000 00000000 00000001
        // 3、得到结果（补码）的原码（正数，三码合一）：00000000 00000000 00000000 00000001 -> 1
        System.out.println(~-2);

        // 1、得到 2 的补码（正数，三码合一）：00000000 00000000 00000000 00000010
        // 2、进行 ~2 操作：11111111 11111111 11111111 11111101
        // 3、得到结果（补码）的原码（负数）
        //      （1）得到结果（补码）的反码：11111111 11111111 11111111 11111100
        //      （2）得到结果（补码）的原码：10000000 00000000 00000000 00000011 -> -3
        System.out.println(~2);

        // 1、得到 2 的补码（正数，三码合一）：00000000 00000000 00000000 00000010
        // 2、进行 2 >> 2 操作：00000000 00000000 00000000 00000000
        // 3、得到结果（补码）的原码（0，三码合一）：00000000 00000000 00000000 00000000 -> 0
        System.out.println(2 >> 2);

        // 1、得到 -2 的补码（负数）
        //      （1）得到 -2 的原码：10000000 00000000 00000000 00000010
        //      （2）得到 -2 的反码：11111111 11111111 11111111 11111101
        //      （3）得到 -2 的补码：11111111 11111111 11111111 11111110
        // 2、进行 -2 >> 2 操作：11111111 11111111 11111111 11111111
        // 3、得到结果（补码）的原码（负数）
        //      （1）得到结果（补码）的反码：11111111 11111111 11111111 11111110
        //      （2）得到结果（补码）的原码：10000000 00000000 00000000 00000001 -> -1
        System.out.println(-2 >> 2);
    }
}

• 输出结果

2
1
-3
0
-1

---

十一、运算符优先级

优先级	运算符	运算顺序
1	()、[]、{}	-
2	!、+（正号）、-（负号）、~、++、–	左 <-- 右
3	*、/、%	左 --> 右
4	+（加号）、-（减号）	左 --> 右
5	<<、>>、>>>	左 --> 右
6	<、<=、>、>=、instanceof	左 --> 右
7	==、!=	左 --> 右
8	&	左 --> 右
9	^	左 --> 右
10	|	左 --> 右
11	&&	左 --> 右
12	||	左 --> 右
13	?:	左 --> 右
14	=、+=、-=、*=、/=、%=、<<=、>>=、&=、|=、^=	左 <-- 右

标签：11111111,Java,00000000,补码,System,运算符,原码,out
From： https://blog.csdn.net/weixin_52173250/article/details/143231361