java源码之关键字、标志符、变量和运算符

1、关键字

1.1、定义

定义：被JAVA语言赋予了特殊含义，用作专门用途的字符串（或单词）
特点：全部关键字都是小写字母

上源码：
代码中定义类的关键字class，定义一个订单控制器类

枚举的关键字，一下声明了缓存的类型字段

常用的关键字

1）const、goto为保留字，现阶段版本没用到，但以后版本可能会成为关键字
2）ture，false，null为字面量，又叫直接量或者数据，表示布尔值或者空值

2、保留字

Java 保留字：现有 Java 版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留 字 byValue、cast、future、 generic、 inner、 operator、 outer、 rest、 var 、 goto 、const

3、标识符（identifier）

定义：Java中变量、方法、类等要素命名时使用的字符序列，称为标识符。通俗的讲，标识符就是自己起名的字符序列。

3.1、标识符命名规则——不遵守便报错

1）由26个英文字母大小写，数字0—9，_ 或 $ 组成，不能包含空格
2）数字不可以放开头
3）严格区分大小写，长度无限制（但不建议太长）
4）不可以使用关键字和保留字，但能包含关键字和保留字

标识符命名规范[更加专业]
1）包名：多单词组成时所有字母都小写：比如 com.chuige
2）类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz [大驼峰] 比如： ProductOrderController
3）变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz [小 驼峰， 简称 驼峰法] 比如： chuiLaoShi
4）常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

3、变量

定义：变量是程序中不可或缺的组成单位，是最基本的存储单元。

3.1、概念

内存中的一个存储区域，该区域的数值可在同一类型进行变化
变量构成三要素：数据类型、变量名、存储的值
声明格式：数据类型 变量名 = 变量值
注：在声明时可以先声明后赋值，或声明时直接初始化，如下

2）变量的作用：在内存中保存数据
3）使用变量的注意事项
每个变量必须先声明后使用
使用变量名访问这块区域的数值
变量作用域：定义在所在的 { } 内。当出了作用域，变量不可再次调用
同一作用域内，不能定义重名的变量

3.2、Java中变量的数据类型

分类
基本数据类型：整型类型（byte、short、int、long），浮点型（float、double），字符型（char），布尔型（boolean）
引用数据类型：类（class），接口（interface），枚举（enum），注解（@interface），枚举（record）
注：基本数据类型会反复使用，但引用数据类型主要使用类、接口、数组三种类型
Java数据类型如下图

3.3、变量的使用

1）变量的声明
格式：数据类型 变量名;

//同时声明多个同类型的变量
int a, b, c;
注：变量的数据类型可以是基本数据类型，也可以是引用数据类型
注意命名时“见名知意”，同时声明多个时用英文逗号（,）隔开

2）变量的赋值
给变量赋值，便是把“值”蠢到该变量代表的内存空间。同时，在赋值时，赋值类型必须与变量声明的类型一致或兼容。
语法格式：变量名 = 值；

说明
可以使用合适类型的常量值给已经声明的变量赋值
可以使用其他变量或者表达式给变量赋值
变量可以反复赋值
也可以将变量的声明和赋值一并执行

4、基本数据类型介绍

4.1、整型类型：byte、short、int、long

1）Java各整数类型有固定的表数范围和字段长度，不受具体操作系统的影响，以保证Java程序的可移植性。如下图

2）声明long类型变量时，在赋值时需要以 “l” 或者 “L” 结尾
3）Java程序中声明整型变量通常用int类型，除非不足或表达比较大的数，才会使用 long

补充：计算机的存储单位
1）字节（Byte）：计算机用于计算存储容量的基本单位。
2）位（bit）：数据存储的最小单位。在二进制数系统中，每个0或1都是一个位，叫bit（比特）。
3）转换关系:

 8 bit = 1 Byte
 1024 Byte = 1 KB
 1024 KB = 1MB
 1024MB = 1 GB
 1024GB = 1 TB

4.2、浮点类型：float、double

1）与整数类型类似，Java 浮点类型也有固定的表数范围和字段长度，不受具体操作系统的影响。如下图

2）浮点型常量的表达形式
十进制数形式(必须有小数点)。如：5.12、512.0f、.512
科学计数法形式。如：5.12e2、512E2
3）单精度浮点型（float）：尾数可以精确到7位有效数字。但多数情况下，难以满足需求
4）双精度浮点型（double）：精度是单精度（float）的两倍。通常使用此类型
5）声明float类型变量时，在赋值时需要以 “f” 或者 “F” 结尾
6）Java程序中声明浮点型变量通常用double类型

4.3、字符类型：char

1）char 类型用来表示通常意义上“字符” （占两个字节）
2）Java中所有的字符都是使用Unicode编码，故一个字符可以存储一个字符、一个汉字或其他书面语的一个字符。
3）字符型变量的表达形式
使用单引号（ ’ ’ ）括起来单个字符。如下
char c1 = ‘a’;
char c2 = ‘b’;
直接使用Unicode值来表示字符型常量。如 ‘\uXXXX’，XXXX代表一个十六进制的整数
char c = ‘\u0023’;
// \u0023表示’#’
使用转义字符 ‘ \ ’ 来其后的字符转变为特殊字符常量
char c3 = ‘\n’;
// '\n’表示换行符

Java转义字符如下

4.4、布尔类型：boolean

1）布尔类型用来判断逻辑条件，一般用于流程控制语句中
if条件控制语句
while循环控制语句
for循环控制语句
do-while循环控制语句

2）布尔类型只有两个值：ture、false
注：一般不谈Boolean类型占用的空间大小，但在真正的内存分配中占4个字节

5、基本数据类型变量间运算规则

1）介绍：在Java程序中，不同的基本数据类型（只有7种，不包含boolean类型）变量的值经常需要进行相互转换
2）转换的方式

自动类型提升
强制类型转换

5.1、自动类型提升

1）将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型
转化形式如图

2）规则
把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量，按照范围大的标准赋值
// 正确类型提升
int i = ‘A’; // char自动升级为int
double = 20; // int自动升级为double类型
long num = 1234567; // 如果后面的值（1234567）在整数范围内，可以正常编译运行
// 错误类型提升
byte bigB = 130; //右边的整数超过byte范围
long bigNum = 12345678900L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过
当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算
当byte、short、char数据类型的变量进行算术运算时，按照int类型处理

5.2、强制类型转换

（1）将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型

注：自动类型提升是由Java自动执行的，而强制类型转换是自动类型提升的逆运算，需要我们自己手动执行

（2）转换格式：数据类型1 变量名 = (数据类型)被强制转换的数据值;

注：() 中的数据类型 必须<= 变量值的数据类型

当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。如下
int i = (int)3.44 // 损失精度

double d = 1.2;
int num = (int)d; // 损失精度

int i = 200;
byte b = (byte)i; // 溢出
当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换没有风险
附：为什么标识符的声明规则要求不能字符开头。如下

// 如果可以数字开头，那下面的代码便可通过
int 12L = 120;
long l = 12L;
// 那么声明l的值是12， 还是变量12L对应的12？
//二者出现歧义，则规则要求不能字母开头
5.3、String与基本数据类型的运算
（1）字符串类型：String

String类，属于基本数据类型。俗称——字符串
使用双引号（ " " ）来表示一个字符串，内部可以包含0到N个字符
声明方式与基本数据类型类似。
（2）运算规则

任意八种基本数据类型的数据与String类型只能进行连接 “+” 运算，且结果一定也是String类型。如下
System.out,println(“” + 6 + 6); // 输出结果为66

boolean a = true;
int num = 10;
String s1 = “fate”;

// 错误示例
String s2 = a + num + s1;
// 理由：运算是从左到右，而布尔型（a）和整型（num）不能进行运算

// 正确示例
String s3 = s1 + a + 10;
String s4 = a + (num + s1);
String类型不能通过强制类型()转换，转为其他的类型
注：String转其他类型可用 Integer ，借助包装类的方法转，但后期才会学到

6、运算符（Operator）

1）定义：运算符是一种特殊的符号，用于表示数据的运算、赋值和比较等。
2）运算符的分类
按功能分类： 算术运算符、赋值运算符、比较(或关系)运算符、逻辑运算符、位运算符、条件运算符、Lambda运算符
按操作数个数分类：一元运算符（单目运算符）、二元运算符（双目运算符）、三元运算符 （三目运算符）

6.1、算数运算符

1）基本语法，如下图所示
2）对部分运算符简单介绍
1）加、减、乘、除、取模（主要介绍除和取模）

除法介绍：用于整数除法和浮点数除法

分母不能为0
当除数与被除数都为整数时，得到的结果是除数
取模介绍：取模结果与被取模数的符号相同

// 除法举例
int a = 3;
int b = 4;
System.out.println(a / b); // 得到的结果会是0，而不是0.75

// 取模举例
System.out.println(5 % 2);//1
System.out.println(5 % -2);//1
System.out.println(-5 % 2);//-1
System.out.println(-5 % -2);//-1
2）“ + ” 的两种用法

用法1：对于 + 两边都是数值， + 就是加法的意思（不多赘述）
用法2：对于 + 两边至少有一边是字符串， + 就是拼接的意思
举例如下

System.out.println(“Hello” + “World”); // HelloWorld

System.out.println(""Java + 520); // Java520

System.out.println(str2 + 5 + 20); // Java520
3）自加、自减运算

理解：++运算表示自增1.同理，–运算表示自减1

单独使用
变量在单独运算的时候，变量前++和变量后++，是没有区别的
复合使用
和其他变量放在一起使用或者和输出语句放在一起使用，前++和后++就产生了不同
变量前++ ：变量先自增1，然后再运算
变量后++ ：变量先运算，然后再自增1
// 单独使用举例
int a = 3;
//++a;
a++;
System.out.println(a); // 无论是变量前++还是变量后++，结果都是4

// 复合使用举例
int x = 3;
int y = ++x; // y的值是4，x的值是4，
int y = x++; // y的值是3，x的值是4
6.2、赋值运算符
（1）基本语法

符号：=
当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
支持连续赋值
扩展赋值运算符： +=、 -=、*=、 /=、%=

对于赋值方法简单说明

// 对于事项变量加一的方法：
// 写法1：最优选择
int num1 = 10;
num1++;

//写法2：第二
int num2 = 10;
num2 += 1;

// 写法3：第三
int num3 = 10;
num3 = num3 + 1;
附：为什么说自增的写法为最优？

因为自增不会涉及到自动类型转换，而是再原本存储位置 +1 ，而另外两种有可能因为自动类型提升而导致运算出现错误。

6.3、比较（关系）运算符
比较简单，直接上图

特点：

比较运算符的结果都是boolean型，也就是要么是true，要么是false

、<、>=、<= ：只适用于基本数据类型（除boolean类型之外）
、!= ：适用于基本数据类型和引用数据类型
注：比较运算符 相等于"" 不能误写成 赋值"="

7.4、逻辑运算符
（1）定义：逻辑运算符，操作的都是boolean类型的变量或常量，而且运算得结果也是boolean类型的值，常使用于条件判断结构、循环结构等。如下图

（2）运算符：&（逻辑与）、&&（短路与）、|（逻辑或）、||（短路或）、！（非）、^（异或）

（3）运算符说明

& 和 &&：表示"且"关系，当符号左右两边布尔值都是true时，结果才能为true。否则，为false
| 和 || ：表示"或"关系，当符号两边布尔值有一边为true时，结果为true。当两边都为false时，结果为false
! ：表示"非"关系，当变量布尔值为true时，结果为false。当变量布尔值为false时，结果为true
^ ：当符号左右两边布尔值不同时，结果为true。当两边布尔值相同时，结果为false
注：逻辑运算符用于连接布尔型表达式，在Java中不可以写成数学表达式 3 < x < 6，应该写成 x > 3 & x < 6

（4）& 、| 、^ 、! 记忆技巧

& 与，且；有false则false
| 或；有true则true
^ 异或；相同为false，不同为true
! 非；非false则true，非true则false
（5）区分 “&” 和 “&&”

相同点：

如果符号左边是true，则二者都执行符号右边的操作
不同点：

& ： 如果符号左边是false，则继续执行符号右边的操作
&& ：如果符号左边是false，则不再继续执行符号右边的操作
建议：开发中，推荐使用 &&

代码举例如下

public class LoginTest {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;

	System.out.println((a > b) & (a++ > c)); // false
                     // 此处 a > b 虽然为假，但操作符为 & 故继续执行 a++ > c
    System.out.println("a = " + a);  // a = 4

    System.out.println((a > b) && (a++ > c)); // false
                     // 此处 a > b 为假，操作符为 && 跳过执行 a++ > c
    System.out.println("a = " + a);  // a = 4

    System.out.println((a == b) && (a++ > c)); // false
                     //  此处 a == b 为真，继续执行 a++ > c
    System.out.println("a = " + a);  // a = 5
}

}

（6）区分 “|” 和 “||”

相同点：

如果符号左边是false，则二者都执行符号右边的操作
不同点：

& ： 如果符号左边是true，则继续执行符号右边的操作
&& ：如果符号左边是true，则不再继续执行符号右边的操作
建议：开发中，推荐使用 ||

代码举例如下

public class LoginTest {
public static void main(String[] args) {
int a = 3;
int b = 4;
int c = 5;

	System.out.println((a > b) | (a++ > c)); // false
                      // 此处 a > b 为假，继续执行 a++ > c ，还是为假
    System.out.println("a = " + a); // a = 4

    System.out.println((a > b) || (a++ > c)); // false
                      // 此处 a > b 为假， 继续执行 a++ > c ，还是为假
    System.out.println("a = " + a); // a = 5

    System.out.println((a > b) || (a++ > c)); // true
                      // 此处 a > b 为真，不再继续执行 a++ > c
    System.out.println("a = " + a); // a = 5
}

}

7.5、位运算符

（1）基本语法

注：位运算符的运算过程全都是基于二进制的补码运算

（2）左移：<<

运算规则：在一定范围内，数据每向左移动一位，相当于原数据*2。（正负数均适用）

注：

当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位
当操作数为负数时，运算过程使用补码，结果使用原码
举例如下

（3）右移：>>

运算规则：在一定范围内，数据每向右移动一位，相当于原数据/2。（正数、负数都适用）

注：

如果不能整除，则向下取整
若为正数，二进制符号位补 0
若为负数，二进制符号位补 1
举例如下（与左移类似）

69 >> 4 类似于 69 / 2的4次 -> 69 / 16 = 4
-69 >> 4 类似于 -69 / 2的4次 -> -69 / 16 = -5
（4）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0。（正数、负数都适用）

举例如下（正数与左移类似）

69 >>> 4 类似于 69 / 2的4次 = 69 / 16 = 4
-69>>>4 结果：268435451， 如下

（5）按位与：&

运算规则：对应二进制位都是1才为1，否则为0

1 & 1 结果为 1
1 & 0 结果为 0
0 & 1 结果为 0
0 & 0 结果为 0
如有负数，依旧先转换位补码再进行运算
举例如下

（6）按位或：|

运算规则：对应二进制位只要有1即为1，否则为0

1 | 1 结果为 1
1 | 0 结果为 1
0 | 1 结果为 1
0 | 0 结果为 0
如有负数，依旧先转换位补码再进行运算
举例如下（与按位与相似，不做太多赘述，可自己尝试运算）

9 | 7 //结果： 15
-9 | 7 //结果： -9
（7）按位异或：^

运算规则：对应位一个为1一个为0，才为1，否则为0

1 ^ 1 结果为 0
1 ^ 0 结果为 1
0 ^ 1 结果为 1
0 ^ 0 结果为 0
如有负数，依旧先转换位补码再进行运算
举例如下（与按位与相似，不做太多赘述，可自己尝试运算）

9 ^ 7 //结果为14
-9 ^ 7 //结果为-16
（8）按位取反：~

运算规则：对应位为1，则结果为0；对应位为0，则结果为1

~0就是1
~1就是0
如有负数，依旧先转换位补码再进行运算
举例如下

7.6、条件运算符

1）基本语法
条件运算符格式：（条件表达式）? 表达式1 : 表达式2
注：
条件表达式是boolean类型的结果，根据boolean的值选择表达式1或表达式2，如下
如果运算后的结果赋给新的变量，要求表达式1和表达式2为同种或兼容的类型

2）与if-else的转换关系
凡是可以使用条件运算符的地方，都可以改写为if-else结构。反之，不成立
开发中，如果既可以使用条件运算符，又可以使用if-else，推荐使用条件运算符。因为执行效率稍高
注：若对条件运算符不熟悉，基本可用 if-else 代替，不用特地得使用

7.7、运算符优先级

运算符有不同的优先级，所谓优先级就是在表达式运算中的运算符顺序。
如下图，优先级由上往下依次递减

1. 一元运算符(从右向左)：++、--、+(正号)、-(负号)、!(逻辑非)、~(按位取反)2
2. 算术运算符：*、/、%(取模)
3. 加法和减法运算符：+、`
4. 移位运算符：<<(左移)、>>(带符号右移)、>>>(无符号右移)
   5). 关系运算符：<、>、<=、>=、instanceof
   6). 相等运算符：==、!=
   7). 位运算符：&(按位与)、^(按位异或)、|(按位或)
   8). 逻辑运算符：&&(逻辑与)、||(逻辑或)
   9). 条件运算符(三元运算符)：? :
   10). 赋值运算符：=, +=, -=, *=, /=, %=, <<=, >>=, >>>=, &=, ^=, |=
   需要注意的是，运算符的优先级决定了它们的计算顺序，但在需要时可以使用括号来改变运算的顺序。

建议：
不要过多的依赖运算的优先级来控制表达式的执行顺序，这样可读性太差，可使用 () 来控制表达式的执行顺序
不要把一个表达式写得过于复杂，如果一个表达式过于复杂，则分几步完成