Java语言基础（关键字、标识符、注释、常量、变量、运算符）

Java语言基础组成：关键字、标识符、注释、常量和变量、运算符、语句、函数、数组

一. 关键字

【注】关键字的所有的字母都是小写

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

基本数据类型	数值型	整数：byte（字节） short（短整型） int （整型） long（长整型）
浮点数： float（单精度浮点数） double（双精度浮点数）
字符型	char（字符型）
布尔型	boolean（布尔型）
引用数据类型	chass（类） interface（接口）
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（同步） Enum（枚举）

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

 extends（继承类） implements（实现接口）

 7. 用于定义建立实例及引用实例，判断实例的关键字 

 new（实例化类） this（本类对象） super（父类对象） instanceof（判断对象类型）

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

 try（检查异常） catch（抓住异常） finally（发生异常后最终执行）  

 throw（程序中实例化异常抛出） throws（标识方法抛出异常）

 9. 用于包的关键字 

 package（创建包名） import（引入包名）

 10. 其他修饰符关键字
native（本地）

native关键字说明其修饰的方法是一个原生态方法，方法对应的实现不是在当前文件，而是在用其他语言（如C和C++）实现的文件中。

strictfp（strict float point
(精确浮点)）

使用strictfp关键字声明一个方法时，该方法中所有的float和double表达式都严格遵守FP-strict的限制,符合IEEE-754规范。当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。

transient（变量修饰符，用它声明一个实例变量，在对象序列化时不会被序列化）

当对象被序列化时（写入字节序列到目标文件）时，transient阻止实例中那些用此关键字声明的变量持久化；当对象被反序列化时（从源文件读取字节序列进行重构），这样的实例变量值不会被持久化和恢复。例如，当反序列化对象——数据流（例如，文件）可能不存在时，原因是你的对象中存在类型为java.io.InputStream的变量，序列化时这些变量引用的输入流无法被打开。

volatile（类型修饰符，用来修饰被不同线程访问和修改的变量）

Java 语言提供了一种稍弱的同步机制,即 volatile 变量.用来确保将变量的更新操作通知到其他线程,保证了新值能立即同步到主内存,以及每次使用前立即从主内存刷新. 当把变量声明为volatile类型后,编译器与运行时都会注意到这个变量是共享的.

assert （断言，可以看作是异常处理的一种高级形式，用于捕捉我们在代码中做出的假设）

在Java中，assert关键字是从JAVA SE 1.4 引入的，为了避免和老版本的Java代码中使用了assert关键字导致错误，Java在执行的时候默认是不启动断言检查的（这个时候，所有的断言语句都将忽略！），如果要开启断言检查，则需要用开关-enableassertions或-ea来开启。

二. 标识符

标识符是在程序中自定义的一些名称，由大小写字母[a-zA-Z]，数字[0-9]，下划线[ _ ]，特殊字符[$]组成。

1. 标识符的命名规则：

（1） 数字不可以开头 

（2） 不可以使用关键字 

（3） Java中严格区分大小写

 【注】“main”不是关键字，但被JVM（Java虚拟机）识别

2. 标识符的名称规范：

（1） 包名：多个单词组成时，所有字母小写 

  e.g. xxxyyyzzz 

（2） 类名和接口名：多个单词组成时，所有单词首字母大写 

  e.g. XxxYyyZzz 

（3） 变量名和函数名：多个单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写 

  e.g. xxxYyyZzz 

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

  e.g. XXX_YYY_ZZZ

三. 注释

Java的注释有三种：单行注释，多行注释，文档注释（是程序的说明书，Java特有的，使用javadoc执行程序可以提取出来形成网页，给开发人员看的）。

//（单行注释）

/*
（多行注释）
*/

/**
（文档注释）
@author 作者
@version 版本号
*/

1
2
3
4
5
6
7
8
9
10
11

1. 注释的作用：

（1） 注解说明程序，但是注意不要每一行都加注释，不然会导致中英文结合地非常密，阅读性差 

（2） 调试程序（很重要的应用）

2. 注释的问题：

（1） 单行注释中能够使用单行注释 

（2） 多行注释中能够使用单行注释 

（3） 多行注释中不能使用多行注释，文档注释 

（4） 文档注释中不能使用文档注释，多行注释

3. 注释的分别用法：

（1） 类上面加的是文档注释 

（2） 函数上面加的是文档注释 

（3） 如果修饰符有改变的话，加多行注释 

（4） 代码中的某几句话，加单行注释

四. 常量

常量不能被改变数值

1. 常量包括：

（1）整数常量 

（2）小数常量 

（3）布尔型常量：true，false 

（4）字符常量：’4’，单个字母 

（5）字符串常量：”abc” 

（6）null常量，值为null

2. 整数常量：

（1）十进制[0-9]，满10进1 

（2）八进制[0-7]，用0开头 

（3）十六进制[0-9A-F]，用0x开头 

（4）二进制[0-1]，8位1,0表示一个字节，字节是一个数据单位。 

【注】ASCII码使用指定的7位或8位二进制数组合来表示128或256种可能的字符。 

  e.g. 01000001表示A 

  e.g. 01000002表示B

2.1 十进制->二进制：

原理：对十进制数进行除2运算

【实例】：6的二进制

System.out.println(Integer.toBinaryString(6)); //打印结果为110

1

2.2 二进制->十进制：

原理：对二进制数乘以2n运算（n是从0开始）

【实例 1】：110 => 0∗20+1∗21+1∗22=6

【实例 2】：00110101的十进制（便捷式）



（【注】8个1 = 255； 7个1 = 127）

【实例 3】：5 + 4 = 9 内存中的算法：101 + 100 = 1001 =>9

2.3 二进制->十六进制：

原理：四个二进制位就是一个十六进制位（1111 => 15 = 24−1）

【实例】：十进制90的十六进制

2.4 二进制->八进制：

原理：三个二进制位就是一个八进制位（111 => 7 =23−1）

【实例】：十进制90的八进制



【注】其他进制转换：先把十进制转换为二进制，再对应地进行转换

2.5 负数的二进制变现形式：

6 =>110 

-6：其实就是6的二进制取反+1（取反：将二进制的1变成0，0变成1） 

【注】整数在内存中为4个字节，1个字节为8位

【实例 1】：十进制6的转换为-6的过程



结论：负数的最高位都是1，取反得来。

【实例 2】：（拓展）求111…111001=？ 【解题思路】：先减1，再取反，再加负号

五. 变量

变量就是将不确定的数据进行存储，也就是需要在内存中开辟一个空间。（Java是强类型语言） 



【注】：Java在方法中定义的变量不会自动初始化，必须要我们给它初始化后才能使用它。在类中定义的变量会自动初始化。

1. 变量的初始化：

（1）Java在方法中定义的变量不会自动初始化，必须要我们给它初始化后才能使用它。 

（2）在类中定义的变量会自动初始化。

2. 变量的作用域：

Java中变量的作用域——大括号划分

{
int x = 9;
}
System.out.println(x); //不可以在大括号外调用X

1
2
3
4

3. 变量的嵌套定义：

（1）Java同一函数中变量不允许嵌套定义（和C语言中不同）

public static void main(String[] args)
{
int x = 3;
{
int x = 9; //不允许嵌套定义
System.out.println(x);
}
System.out.println(x);
}

1
2
3
4
5
6
7
8
9

（2）Java同一类中允许方法中的变量与成员变量同名

class Demo
{
private int x;
public int getX()
{
int x = ++this.x;
return x; //此处调用的是方法中定义的x,而非类的成员变量
}
}

1
2
3
4
5
6
7
8
9

六. 运算符

处理数据的原理就是运算。运算符包括：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三元运算符。

1. 算术运算符：

+（正号）	-（负号）
+（加）	-（减）	*（乘）	/（除）【e.g.】5 / 5 = 1
%（取模） 规律：左边小于右边 = 左边 【e.g.】 2 %5 = 2;           左边等于右边 = 0 【e.g. 】5 %5 = 0;           右边等于1 = 0 【e.g. 】5 %1 = 0;
+（字符串相加） 字符串数据和任何数据使用【+】都是相连接，最终都会变成字符串           【e.g.】(“He” + “llo”) =>(“Hello”)
++（自增）	自增前（先自增，后赋值）： a = 2; b = ++a;  => a = 3 ; b = 3;
自增后（先赋值，后自增）： a = 2; b = a++;  => a = 3 ; b = 2;
【总结】：a++; => a = a + 1;       a++和++a运算过后，a的值都增加1
- -（自减）	自减前（先自减，后赋值）： a = 2; b = - -a;  => a = 1 ; b = 1;
自减后（先赋值，后自减）： a = 2; b = a- -;  => a = 1 ; b = 2;

【实例】：”+” 字符串连接符的用法

System.out.println("5+5=" + 5 + 5); //5+5=55
System.out.println("5+5=" + (5+5)); //5+5=10
System.out.println("a=" + a + ", b=" + b); //a=4, b=5

1
2
3

2. 赋值运算符

=（赋值）	+=（和赋值）	-=（差赋值）	*=（积赋值）	/=（商赋值）	%=（余数赋值）
【注】：以上的符号如”-=” 都是仅为一个运算符符号

【实例1】x += 4; => x = x + 4; 

    左右两边的和赋值给左边

【实例2】两个赋值方法对比

short s = 4;  s = s + 4;	short s = 4;  s += 4;
先做加法，再做赋值，有自动类型提升的过程	这个只做了一次运算，只是运用了赋值运算符，把左右两边的和赋值给左边
【编译失败】，因为s会被提升为int类型，运算后的结果还是int类型，无法赋值给short类型	【编译成功】，因为”+=”赋值运算符在给s赋值时，自动完成了强转操作
总结：s = (short) (s + 4)这样才能将和赋值给s	总结：(1)s = 4; (2)s += 4; 这两个表达式都只用了赋值运算符，将int类型赋值给short型，会进行自动类型转换

3. 比较运算符：

比较运算符结果都是boolean型，true 或者 false。

==（相等）	！=（不相等）	<（小于）	>（大于）	<=（小于等于）	>=（大于等于）
instanceof（检查是否是类的对象）

【实例】：

System.out.println("Hello" instanceof String); //true
System.out.println(3 > 4); //false

1
2

4. 逻辑运算符：

逻辑运算符代表关系，用于连接boolean类型的表达式。

&	And （与）	true  &  true  = true true  &  false = false false &  true  = false false &  false = false	【结论】：  两边只要有一个为false，结果就是false，  两边只要都为true，结果为true。	【实例】： int x = 4;  x > 3 & x < 4 = false; true & true = true;
|	or （或）	true  |  true  = true true  |  false = true false |  true  = true false |  false = false	【结论】：  两边只要有一个true，结果为true，  两边只要都为false，结果为false。
^	xor （异或）	true  ^  true  = false true  ^  false = true false ^  true  = true false ^  false = false	【结论】：  两边相同，结果为false，  两边不同，结果为true。
！	Not （非）	！true = false
&&	And （短路）	【 & 与 && 的区别】：  &：无论左边是true，还是false，右边都运算。  &&：当左边为false时，右边不运算，因为结果肯定为false，      左边为true，右边参与运算。
||	or （短路）	【 | 与 || 的区别】：  |：无论左边是true，还是false，右边都运算。  ||：当左边为true时，右边不运算，因为结果肯定为true，    左边为false，右边参与运算。

5. 位运算符：

位运算符是二进制运算的运算符，“位”是二进制的位，是最快的运算，但局限是基为2。

<<	左移	3 << 2   => 3∗22=12
>>	带符号右移	3 >> 1   => 3 / 21=1	高位空出来要补什么？ 按原有数据的高位置是0补0，是1补1。
>>>	无符号右移	3 >>> 1 => 3 / 21=1	右移空出来都拿0补
&	与运算	6 & 3 = 2
|	或运算	6 | 3 = 7
^	异或运算	6 ^ 3 = 5
~	反码	~6 = -7

【实例】：左移，右移，无符号右移之间的区别

【 1. << 与 >> 的区别】：
<<（左移）	其实就是乘以2的移动位数为次幂
>>（右移）	其实就是除以2的移动位数为次幂
【 2. >> 时，正数和负数 的区别】：
>>（正数右移时）	高位补0
>>（负数右移时）	高位补1
【 3. >> 与 >>> 的区别】：
>>（带符号右移）	高位补0或1：具体看原有值高位，是0补0，是1补1
>>>（无符号右移）	高位都补0

5.1 <<（左移）：

【实例 】： 3 << 2  
=> 3∗22=12



【总结】：m << n  
=> m∗2n  （向左边移动，右边用0补。）

5.2 >>（右移）：

【实例 1】： 正数右移：3 >> 1  
=> 3 / 21=1



【总结】：m >> n  
=> m / 2n  

【实例 2】： 负数右移： −3 >> 1  
=> −3 / 21=−2

（1）将3转换为二进制的-3（取反加1） 

（2）将二进制的-3右移1位，高位用1补（负数高位为1） 

（3）将二进制的-3转换为十进制（减1取反）



【总结】：负数右移还是负数。

5.3 >>>（无符号右移）：

【实例 1】： 正数无符号右移：3 >>> 1  
=> 3 / 21=1



【实例 2】： 负数无符号右移：-3 >>> 1  
=> −3 / 21=2147483646



【总结】：如果是负数右移的话，高位也补0，此时的数就转变为了正数

5.4 &（与运算）：

【实例】： 6 & 3 = 2

5.5 | （或运算）：

【实例】： 6 | 5 = 7

5.6 ^（异或运算）：

【实例 1】： 6 ^ 5 = 3



【实例 2】：异或运算还可以用于加密解密： 7 ^ 4 ^ 4 = 7;（“4”相当于密钥）



【总结】：一个数异或同一个数两次，结果是本身。

5.7 ~（反码）：

【实例】： ~6 = -7  步骤：（1）取反，（2）减1，（3）取反，（4）加负号

5.8 位运算练习：

【实例 1】：最有效的方式算出2乘以8等于几？

 解： 2 * 8 = 2∗23 =>
2的二进制位向左移了3位； 

    2的二进制为000..0000-0010 

    左移了3位：000..0001-0000 => 16

【实例 2】：对两个整数变量的值进行交换（不需要第三方变量）

// （1）使用第三方变量
int n = 3, m = 8;
int temp;
temp = n;
n = m;
m = temp;

// （2）不需要使用第三方变量，利用两数的和
n = n + m;
m = n - m;
n = n - m;

// （3）不需要使用第三方变量，利用异或同一个数两次还是本身
n = n ^ m;
m = n ^ m; //m = (n ^ m) ^ m;
n = n ^ m; //n = (n ^ m) ^ n;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

【实例 3】： 60（十进制）转换为十六进制，用代码

public static void main(String[] args)
{
int num = 60;

//取出最低4位，方法：通过&15
int n1 = num & 15;

//输出最低4位的十六进制值
System.out.println(n1 > 9 ? (char)(n1 - 10 + 'A') : n1);
//char是两个字节，int是四个字节，(n1 - 10 + 'A')会自动类型提升为int型，所以输出结果为67

//获取下一组4位，右移4位
int temp = num >>> 4;
int n2 = temp & 15;
System.out.println(n2 > 9 ? (char)(n2 - 10 + 'A') : n2);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

【实例 4】：（扩展） -60（十进制）转换为十六进制

6. 三元运算符：

（条件表达式）？ 表达式 1 ： 表达式 2； =>一定有结果

（1）如果条件为true， 运算后的结果为表达式 1； 

（2）如果条件为false，运算后的结果为表达式 2；