文章目录
- 1. 算术运算符
- 2. 关系运算符（比较运算符）
- 3. 逻辑运算符
- 4. 赋值运算符
- 5. 三元运算符
- 5. 运算符的优先级
- 6. 标识符命名规则和规范
- 7. 关键字
- 8. 保留字
- 9. 键盘输入
- 10. 进制
- 10.1 进制介绍
- 10.2 进制转换
- 10.3 原码、反码、补码
- 10.4 位运算
1. 算术运算符
运算符 | 运算 |
+ | 正号 |
- | 负号 |
+ | 加 |
- | 减 |
* | 乘 |
/ | 除 |
% | 取模（取余） |
++ | 自增 |
– | 自减 |
+ | 字符串拼接 |
除法（/）：Java中，整型数据除法运算结果的舍入规则与C语言中相同，都是向0舍入。
int a = 3/2; //float除法应该为 1.5
int b = 5/3; //float除法应该为 1.666
int c = 5 /4; //~~~~~~~~~~~~ 1.25
int d = -3/2; //~~~~~~~~~~~~ -1.5
int e = -5/3; //~~~~~~~~~~~~~~ -1.66
int f = -5/4; //~~~~~~~~~~~~~~ -1.25
System.out.printf("a is %d\nb is %d\nc is %d\n" +
"d is %d\ne is %d\nf is %d\n",
a, b,c,d,e,f);输出结果：
a is 1
b is 1
c is 1
d is -1
e is -1
f is -1浮点型数据除法运算结果小数部分的位数：若能整除，显示整数+“.0”（如2.0）；若能除尽且有小数，显示有效的位数，小数末尾的0不显示；若不能除尽，显示该数据类型能保留的位数。
float a = 10F;
System.out.println(a / 2);//5.0
System.out.println(a / 4);//2.5
System.out.println(a / 8);//1.25
System.out.println(a / 16);//0.625
System.out.println(a / 3);//3.3333333
System.out.println(a / 7);//1.4285715
double b = 10;
System.out.println(b / 2);//5.0
System.out.println(b / 4);//2.5
System.out.println(b / 8);//1.25
System.out.println(b / 16);//0.625
System.out.println(b / 3);//3.3333333333333335
System.out.println(b / 7);//1.4285714285714286取模（%）：a % b 的本质是 a - a / b * b
System.out.println(10 % 3); //1
System.out.println(-10 % 3); // -10 - (-10) / 3 * 3 = -1
System.out.println(10 % -3); // 10 - 10 / (-3) * (-3) = 1
System.out.println(-10%-3); // -10 - (-10) / (-3) * (-3) = -1当a是小数时，a % b = a - (int)a / b * b
-10.5 % 3 = -10.5 - (-10) / 3 * 3 = -10.5 - (-3) * 3 = -1.5
自增（++）/ 自减（- -）：
作为独立语句使用时：i++ 和 ++i 都完全等价于 i = i + 1;
作为表达式使用时：++i 先自增后赋值；i++ 先赋值后自增。
int i = 10;
i++;
++i;
System.out.println("i=" + i); //12
int j = 8;
int k = ++j; //等价于j=j+1; k=j
System.out.println("k = "+ k + " j=" + j);//9 9
k = j++; //等价于k =j; j=j+1;
System.out.println("k = "+ k + " j=" + j);//9 10练习题：
int i = 1;
i = i++;
System.out.println(i); // 输出1上面的代码做了这样的工作：temp = i; i = i + 1; i = temp;
int i = 1;
i = ++i;
System.out.println(i); // 输出2上面的代码做了这样的工作：i = i + 1; temp = i; i = temp;
2. 关系运算符（比较运算符）
关系运算的结果都是boolean型，或者为true，或者为false。
运算符 | 运算 | 范例 | 结果 |
== | 等于 | 8 == 7 | false |
!= | 不等于 | 8 != 7 | true |
< | 小于 | 8 < 7 | false |
> | 大于 | 8 > 7 | true |
<= | 小于等于 | 8 <= 7 | false |
>= | 大于等于 | 8 >= 7 | true |
instanceof | 检查是否是类的对象 | “hsp” instanceof String | true |
int a = 9;
int b = 8;
System.out.println(a > b); //T
System.out.println(a >= b); //T
System.out.println(a <= b); //F
System.out.println(a < b);//F
System.out.println(a == b); //F
System.out.println(a != b); //T
boolean flag = a > b; //T
System.out.println("flag=" + flag) ;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 | false | true | true | false | true |
false | true | false | false | true | true | true | true |
false | false | false | false | false | false | true | false |
短路与（&&）、逻辑与（&）：两个条件都为 true，结果为 true，否则 false。区别如下：
- 短路与（&&）：如果第一个条件为 false，则第二个条件不会判断，最终结果为 false，效率高。
- 逻辑与（&）：不管第一个条件是否为 false，第二个条件都要判断，效率低。
- 开发中， 基本都是使用&&。
短路或（||）、逻辑或（|）：两个条件中只要有一个true，结果为 true，否则为false。区别如下：
- 短路或（||）：如果第一个条件为 true，则第二个条件不会判断，最终结果为 true，效率高。
- 逻辑或（|）：不管第一个条件是否为 true，第二个条件都要判断，效率低。
- 开发中，基本都是使用 ||。
取反（!）：true ➡ false，false ➡ true。
异或（^）: 不同为true，相同为false（求异）。
boolean b = (10 > 1) ^ (3 < 5);
System.out.println( b);//false4. 赋值运算符
种类：
- 基本赋值运算符：=
- 复合赋值运算符：+= ，-= ，*= ， /= ，%= 等
使用细节：
- 运算顺序从右往左 int num= a + b + c;
- 赋值运算符的左边只能是变量，右边可以是变量、表达式、常量值
int num = 20;
int num2 = 78*34-10;
int num3 = a;- 复合赋值运算符等价于这样的的效果，比如：a += 3; 等价于a = a + 3; 其他类推。
- 复合赋值运算符会进行类型转换，“a += 3"不是简单的等价于"a = a + 3”。
byte b = 2;
b += 3;//相当于b = (byte)(b + 3)
//b = b + 3; 结果是int，赋值给byte会报错
System.out.println(b);//5
b++;//相当于b = (byte)(b + 1)
//b = b + 1; 结果是int，赋值给byte会报错
System.out.println(b);//65. 三元运算符
条件表达式 ?表达式 1: 表达式 2;
- 运算规则：
如果条件表达式为 true，运算后的结果是表达式 1；
如果条件表达式为 false，运算后的结果是表达式 2；
int a = 10;
int b = 99;
int result = a < b ? a++ : b--;//b--未执行
System.out.println(result); //10
System.out.println(a); //11
System.out.println(b); //99- 表达式1、表达式2要与接收变量的类型相同，或可以自动转换为接收变量的类型。
int a = 3;
int b = 8;
int c = a > b ? (int)1.1 : (int)3.4;//可以
double d = a > b ? a : b+3;//可以的，满足int->double- 三元运算符可以转成 if-else 语句，下面两段代码等价。
int res = a > b ? a++ : --b;if ( a > b)
res = a++;
else
res = --b;5. 运算符的优先级
只有单目运算符、赋值运算符是从右向左运算的。
6. 标识符命名规则和规范
标识符：用于命名变量、方法和类等。凡是自己可以起名字的地方都叫标识符。
标识符的命名规则（必须遵守）：
(1) 由26个英文字母大小写，0-9 ，或 $ 组成。
(2) 不可以用数字开头。
(3) 不可以使用关键字和保留字。
(4) Java中严格区分大小写，长度无限制。
标识符的命名规范（更加专业）：
(1) 包名：多单词组成时，所有字母都小写，如：com.hsp.crm。
(2) 类名、接口名：多单词组成时，所有单词的首字母大写（大驼峰），如： TankShotGame。
(3) 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写（小驼峰），如： tankShotGame。
(4) 常量名：所有字母都大写。多单词时每个单词用下划线连接，如 ： TAX_RATE。
7. 关键字
定义：被 Java 语言赋予了特殊含义，用做专门用途的单词。
特点：关键字中所有字母都为小写。
8. 保留字
现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字：byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const。
9. 键盘输入
接收用户输入的数据，需要一个扫描器(对象), 就是Scanner。步骤为：
(1) 导入该类的所在包，java.util.*；
(2) 创建该类对象（声明变量）；
(3) 调用里面的功能。
要使用一个类，就要先导入它所在的包，不知道类所在的包可以查文档。
import java.util.Scanner;//表示把 java.util 下的 Scanner 类导入
public class Input {
public static void main(String[] args) {
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入姓名");
String name = myScanner.next(); //接收用户输入 String
System.out.println("请输入性别");
char gender = myScanner.next().charAt(0);//接收用户输入 char
System.out.println("请输入年龄");
int age = myScanner.nextInt(); //接收用户输入 int
System.out.println("请输入薪水");
double sal = myScanner.nextDouble(); //接收用户输入 double
System.out.println("人的信息如下:");
System.out.println("姓名=" + name + " 性别=" + gender + " 年龄=" + age + " 薪水=" + sal);
}
}10. 进制
10.1 进制介绍
对于整数，有四种表示方式：
二进制：0,1 ，满 2 进 1，以 0b 或 0B 开头。
十进制：0 ~ 9 ，满 10 进 1。
八进制：0 ~ 7 ，满 8 进 1，以数字 0 开头表示。
十六进制：0 ~ 9 及 A(10) ~ F(15)，满 16 进 1，以 0x 或 0X 开头表示。此处的 A ~ F 不区分大小写。
无论以什么进制赋值给int，输出时都是十进制。
int n1 = 0b1010;//二进制
int n2 = 1010;//十进制
int n3 = 01010;//八进制
int n4 = 0X10101;//十六进制
System.out.println("n1=" + n1);//10
System.out.println("n2=" + n2);//1010
System.out.println("n3=" + n3);//520
System.out.println("n4=" + n4);//65793进制图示：
10.2 进制转换
第一组：
- 二进制 ➡ 十进制：从最低位(右边)开始，将每位上的数提取出来，乘以2(n-1)，再求和。
- 八进制 ➡ 十进制：从最低位(右边)开始，将每位上的数提取出来，乘以8(n-1)，再求和。
- 十六进制 ➡ 十进制：从最低位(右边)开始，将每位上的数提取出来，乘以16(n-1)，再求和。
第二组：
- 十进制 ➡ 二进制：将该数不断除以 2，直到商为 0，然后将每步得到的余数倒过来，就是对应的二进制。
- 十进制 ➡ 八进制：将该数不断除以 8，直到商为 0，然后将每步得到的余数倒过来，就是对应的八进制。
- 十进制 ➡ 十六进制：将该数不断除以 16，直到商为 0，然后将每步得到的余数倒过来，就是对应的十六进制。
第三组
- 二进制 ➡ 八进制：从低位开始，将二进制数每 3 位一组，转成对应的八进制数。
- 二进制 ➡ 十六进制：从低位开始，将二进制数每 4 位一组，转成对应的十六进制数。
第四组
- 八进制 ➡ 二进制：将八进制数每一位，转成对应的一个 3 位的二进制数。
- 十六进制 ➡ 二进制：将十六进制数每一位，转成对应的一个 4 位的二进制数。
10.3 原码、反码、补码
- 二进制的最高位是符号位：0为正，1为负。
- 正数的原码，反码，补码相同。
- 负数的反码 = 原码忽略符号位，各位取反。
- 负数的补码 = 原码忽略符号位，各位取反，末位 + 1；补码 = 反码 + 1；反码 = 补码 - 1。
由原码求补码的快捷方法：符号位不变，从右往左，第一个1及其右边不变，左边按位取反。补码求原码也一样。 - 0的反码，补码都是0。
- Java 没有无符号数。换言之，Java中的数都是有符号的。
- 计算机都是以补码的方式运算。
- 当看运算结果的时候，要看原码。
10.4 位运算
运算 | 描述 |
按位与（&） | 两位全为1，结果为1，否则为0 |
按位或（|） | 两位有一个为1，结果为1，否则为0 |
按位异或（^） | 不同为1，相同为（求异） |
按位取反（~） | 0 ➡ 1，1 ➡ 0 |
例：求 ~2（计算机用补码运算，用原码展示结果）
（1）求 2的补码 00000000 00000000 00000000 00000010
（2）对补码取反 11111111 11111111 11111111 11111101
（3）结果转原码 10000000 00000000 00000000 00000011 = -3
所以，~2 = -3
练习：~-2 = 1， 2&3 = 2
运算 | 官方方法 (注意计算机用补码运算，用原码展示) | 快捷方法 (直接在原码上操作) |
算术右移 （>>） | 符号位不变，其余各位右移，高位用符号位补齐 | 每算术右移一位相当于 / 2（-1比较特殊，无论右移多少结果都是 -1） |
算术左移 （<<） | 符号位不变，其余各位左移，低位补 0 | 每算术右移一位相当于 * 2 |
无符号右移（>>>） | 也叫逻辑右移，各位右移，高位补 0 |
特别说明：没有 <<< 符号
例：-1 << 2
-1的原码： 10000001
-1的补码： 11111111
补码 <<2： 11111100
结果转原码 ： 10000100 = -4（与快捷方法计算一致）
-1 >> 2
-1的原码： 10000001
-1的补码： 11111111
补码 >>2： 11111111
结果转原码 ： 10000001 = -1（与快捷方法计算不一致）
4 << 3 == 32 4 * 2 * 2 * 2 = 32
15 >> 2 ==3 15 / 2 / 2 = 7 / 2 = 3（可以直接15 / 4 ？）
int a = 1 >> 2;
int b = -1 >> 2;
int c = 1 << 2;
int d = -1 << 2;
int e = 3 >>> 2;
System.out.println("a="+a);//a=0
System.out.println("b="+b);//b=-1
System.out.println("c="+c);//c=4
System.out.println("d="+d);//d=-4
System.out.println("e="+e);//e=0
