Java学习笔记（gongy@senptec.com）-2023年3月

类别	关键字	说明
访问控制	private	私有的
	protected	受保护的
	public	公共的
	default	默认
类、方法和变量修饰符	abstract	声明抽象
	class	类
	extends	扩充,继承
	final	最终值,不可改变的
	implements	实现（接口）
	interface	接口
	native	本地，原生方法（非 Java 实现）
	new	新,创建
	static	静态
	strictfp	严格,精准
	synchronized	线程,同步
	transient	短暂
	volatile	易失
程序控制语句	break	跳出循环
	case	定义一个值以供 switch 选择
	continue	继续
	do	运行
	else	否则
	for	循环
	if	如果
	instanceof	实例
	return	返回
	switch	根据值选择执行
	while	循环
错误处理	assert	断言表达式是否为真
	catch	捕捉异常
	finally	有没有异常都执行
	throw	抛出一个异常对象
	throws	声明一个异常可能被抛出
	try	捕获异常
包相关	import	引入
包相关	package	包
基本类型	boolean	布尔型
	byte	字节型
	char	字符型
	double	双精度浮点
	float	单精度浮点
	int	整型
	long	长整型
	short	短整型
变量引用	super	父类,超类
	this	本类
	void	无返回值
保留关键字	goto	是关键字，但不能使用
	const	是关键字，但不能使用

（4）、Java源程序与编译型程序的运行区别

二、对象和类

（1）、基本概念

Java是一种面向对象的编程语言；

Java支持多态、继承、封装、抽象、类、对象、实例、方法、重载九种基本概念；

类(class)：可以看作一个模板，作用是描述一类对象的行为和状态；

对象(object)：可以看作是类的一个实例，包含具体的行为和状态；

举例：可以把一群人按性别分类为男性和女性，在这里，男性和女性可以各看作一个类，而每个分组里具体的人就可以看作对象，再按照一定的规则对具体的人进行区分就可以得到对象的状态和方法；

回归到软件本身，一个软件对象（object）的状态对应的就是其属性；行为则通过方法来体现；

属性可以理解为一类对象共同的特征，比如人的共同特征有性别、身高、年龄、肤色等；

方法可以理解为对象表现出来的行为，比如人的行为包括吃喝拉撒睡等；

一个类包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。这种变量的声明和初始化都在具体的方法中，一个方法的调用结束时，这个方法里的局部变量就会被销毁。

成员变量：在类中但是方法体之外的变量被称为成员变量。这种变量在创建对象时被实例化，类中的方法、构造方法和特定类的语句块都可以访问它；

类变量：同样在类中但是方法体之外的变量，且被声明为static类型的变量叫类型变量；

（2）、构造方法

每个类都有一个构造方法，如果没有显式定义，Java编译器将会为这个类提供一个默认的构造方法。

在创建一个对象时，至少要调用一个构造方法，构造方法必须与类同名，一个类可以拥有多个构造方法；

（3）、对象创建

对象基于一个类来创建，创建对象使用的关键字为：new

创建对象的步骤可分为三步：首要要声明对象的名称和对象的类型；其次要使用关键词将对象实例化；最后调用构造方法初始化对象；

（4）、源文件声明规则

当你在一个源文件中定义了多个类，并且使用了import语句和package语句时，需要注意以下规则：

1）、一个源文件只能存在一个public类，言外之意可以存在多个非public类；

2）、源文件的名称应该与public类的类名保持一致。例如public类的类名叫Mike的话，原件应该叫做Mike.java；

3）、如果你在某个包下定义了一个类， package 语句应该在源文件的首行；

4）、如果你使用import语句引入了某个类/包，应该把他放在 package 语句和类定义之间；

5）、在同一个源文件中，不能给不同的类不同的包声明；

三、基本数据类型

（1）、基本概念

Java中的变量通过申请内存来存储值，当一个申请发出时，内存管理系统会根据变量的类型分配合适的存储空间；不同的数据类型能分配到的空间是不同的，所以两者必须互相对应；

Java将基本数据类型分为两大类：内置数据类型和引用数据类型、

（2）、内置数据类型

Java的内置数据类型又叫基本数据类型，共八种，其中包括六种数字类型（四个整数型，两个浮点型），一种字符型，一种布尔型；

1）、byte：

数据类型：8位、有符号的、以二进制补码表示的整数；

范围区间：-128（-2^7）—— 127（2^7-1）；

默认值：0

使用技巧：因为byte变量在内存中占用的空间只有int的四分之一，byte可用于大型数组中，作用是代替整数；

2）、short：

数据类型：16位、有符号、以二进制补码表示的整数；

范围区间：-32768（-2^15）—— 32767（2^15 - 1）；

默认值：0

使用技巧：因为short变量在内存中占用的空间只有int的二分之一，所以short也可以像 byte 那样节省空间；

3）、int

数据类型：32位、有符号、以二进制补码表示的整数；

范围区间： -2,147,483,648（-2^31）—— 2,147,483,647（2^31 - 1）；

默认值：0

使用技巧：一般地整型变量默认为 int 类型；

4）、long

数据类型：64位、有符号、以二进制补码表示的整数；

范围区间：-9,223,372,036,854,775,808（-2^63）—— 9,223,372,036,854,775,807（2^63 -1）；

默认值：0L

使用技巧：主要使用在需要比较大整数的系统上；

5）、float

数据类型：单精度、32位、符合IEEE 754标准的浮点数；

默认值：0.0f

使用技巧：浮点数不能用来表示精确的值，例如货币；

6）、double

数据类型：双精度、64位、符合IEEE 754 标准的浮点数；

默认值：0.0d

使用技巧：浮点数的默认类型为 double 类型；同样不能用来表示精确的值，例如货币；

7）、boolean

数据类型：表示一位的信息；

范围区间：只有两个值：true或false；

默认值：flase；

8）、char

数据类型：一个单一的 16 位 Unicode 字符；

范围区间：\u0000（十进制等效值为 0）—— \uffff（即为 65535）；

使用技巧：可以储存任何字符；

总结：于数值类型的基本类型的取值范围，一般不需要强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了，不知道的话可以自行去包装类中查看；

（3）、引用数据类型

1）、基本概念：Java中的引用类似于c/c++中的指针。引用类型指向的是一个具体的对象，而这个指向对象的变量就被称作引用变量；引用变量在被声明时会被指定为一个特定的类型，需要注意的是，一旦声明一个引用变量后，其类型不能再改变；

2）、对象、数组都是引用数据类型；

3）、一个引用变量可用于任何与之兼容的类型；

（4）、Java常量

1）、基本概念：Java中使用final关键字来修饰常量，声明方式和变量类似；需要注意的是，常量在程序运行过程中不能被修改；且通常使用大写字母表示常量。

2）、当使用字面量时，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制；

3）、Java的字符串常量是包含在两个引号之间的字符序列；

4）、Java语言支持一些特殊的转义字符序列：

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x0)
\s	空格 (0x20)
\t	制表符
\"	双引号
\'	单引号
\\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

（5）、自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，Java会将不同类型的数据先转化为同一类型，然后再执行逻辑运算。转换从低级到高级如下图所示：

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

转换规则：

1）、不能对boolean类型进行类型转换；

2）、不能把对象类型转换成不相关类的对象；

3）、在把容量大的类型转换为容量小的类型时必须使用强制类型转换；

4）、转换过程中因为不同数据类型的取值范围不同可能导致溢出或精度损失；

5）、浮点数到整数的转换是通过直接舍弃小数得到的，而不是四舍五入；

6）、自动类型转换要求转换前的数据类型的位数要低于转换后的数据类型；

7）、使用强制类型转换的条件是转换的数据类型必须是兼容的；

8）、强制类型转换格式：(type)value type要强制类型转换后的数据类型；

9）、隐含强制类型转换：整数的默认类型为int，小数的默认数据类型为double，这些都算强制类型转换；

10）、在定义float类型时必须在数字后面添加F或者f；

四、变量类型

Java中所有变量在使用前必须进行声明操作，其遵循的规则如下：

type identifier [ = value][, identifier [= value] ...] ;

说明：

1）、type指代Java中的数据类型；

2）、identifier指代变量名称；

3）、可以用逗号隔开的方式同时声明多个同种数据类型的变量；

（1）、Java支持的变量类型

1）、局部变量：指在类的方法中定义的变量；

2）、实例变量：指独立于方法之外，且没有使用static关键字修饰的变量；

3）、类变量：指独立于方法之外，且使用static关键字修饰的变量；

（2）、Java局部变量

1）、声明位置：在方法/构造方法/语句块中；

2）、创建时间：在方法/构造方法/语句块被执行时创建；

3）、销毁时间：在方法/构造方法/语句块执行完毕时销毁；

4）、可见范围：只在声明它的方法/构造方法/语句块中可见；

5）、分配位置：在栈上分配；

6）、默认值：无默认值，声明后必须经过初始化才能正常使用；

7）、其他：访问修饰符不能用于局部变量；

（3）、实例变量

1）、声明位置：在类中，但是方法/构造方法/语句块之外；

2）、声明时间：可以声明在使用前，也可以在使用后；

3）、创建时间：在对象创建时创建；

4）、销毁时间：在对象销毁时销毁；

5）、可见范围：对于类中的方法/构造方法/语句块都是可见的；一般情况下会使用访问修饰符将其设为私有，使得实例变量对子类可见；

6）、默认值：实例变量具有默认值；

数值型变量：0；

布尔型变量：false；

引用类型变量：null；

变量的值可以在声明时指定，也可以在构造方法中指定；

7）、其他：访问修饰符可以用于修饰实例变量；实例变量可以通过变量名访问，但是在静态方法以及其他类中，则需要使用完全限定名；

（4）、类变量（静态变量）

1）、声明位置：在类中、方法之外以static关键字声明；

2）、创建时间：第一次被访问时创建；

3）、销毁时间：程序结束时被销毁；

4）、默认值：与实例变量类似：

数值型变量：0；

布尔型变量：false；

引用类型变量：null；

变量的值可以在声明时指定，也可以在构造方法中指定；与实力变量不同的是，静态变量还可以在静态语句块中初始化。

5）、可见范围：与实例变量相似，考虑到对所在类的使用者可见，一般将静态变量声明为public类型；

6）、分配位置：存储在静态存储区。多用于声明常量。

7）、静态变量可以通过以下这种方式来访问：ClassName.VariableName（类名.静态变量名称）；

8）、当你把一个静态变量名称声明成 public static final 类型时，类变量名称一般会要求以全大写的形式命名。其他类型时命名规则与另外两个变量一致。

五、标识符

（1）、定义

之前提及的所有Java名词都需要自定义名字，这些类名、变量名和方法名称都被称为标识符

（2）、注意事项

1）、所有标识符都应该以英文字母（大小写视具体情况而定），美元符（$）、或者下划线（_）开始;

2）、首字符之后可以是英文字母、美元符、下划线或者数字的字符组合；

3）、Java已有的关键词不能用作标识符；

4）、标识符大小写敏感；

六、修饰符

（1）、定义

修饰符指的是用来定义类、方法或者变量，通常放在语句的最前端。Java中提供的修饰符大致可分为两类：访问修饰符和非访问修饰符。

（2）、访问控制修饰符

1）、default

默认修饰符，即定义变量或者方法时不使用任何修饰符，则编译器会默认为default修饰符；

· 这种变量/方法对同一个包内的类都是可见的；

· 接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public；

2）、private

私有访问修饰符，对访问权限的限制最严格的修饰符；

· 被private修饰符声明的方法，其变量和构造方法只能被所属类访问，并且对应的类和接口不能被声明为private；

· 一旦一个变量被声明为私有访问类型，那外部类只能通过公共方法中的get与set来访问；

· 私有访问修饰符的设计目的是为了隐藏类的实现细节并保护类中的数据；

3）、public

公共访问修饰符，对访问权限的限制最宽松的修饰符；

· 被声明为public的类/方法/构造方法/接口都能被其他任何类访问；

· 如果准备访问的public类分布在不同的包之中，则需要导入对应public类所在的包；

· 由Java类的继承特性可知，公共类中的公有方法和变量都能被其子类继承；

4）、protected

受保护的访问修饰符，对访问权限的限制需要分情况讨论；

· 如果子类与基类在同一包内：此时被声明为protected的变量/方法/构造方法能被同一个包中的任何其他类访问；

· 如果子类与基类不在同一包内：此时在字类中，字类实例可以访问其从基类继承而来的protected方法，但是不能访问基类实例的protected方法；

· protected 可以修饰数据成员/构造方法/方法成员，但是不能修饰类（内部类除外）；

· 需要注意的是：接口及接口的成员变量和成员方法均不能声明为 protected；

· protected修饰符的设计目的之一是保护不相关的类使用某些方法和变量；

访问控制
修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N（说明）	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

5）、继承必须遵守的一些规则

· 父类中声明为 public 的方法在子类中也必须为 public；

· 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private；

· 父类中声明为 private 的方法，不能够被子类继承；

七、运算符

1、运算符分类

（1）、算术运算符：主要用在数学表达式里，包括最基础的加减乘除等。

（2）、关系运算符：主要用在判断表达式里，包括等于、大于、小于等。

（3）、位运算符：主要用在位运算表达式里，包括取反、位移运算符等。

（4）、逻辑运算符：只有逻辑与（&&）、逻辑或（||）和逻辑非（!）三个。

（5）、赋值运算符：可看作前几种运算符的融合简化版。

（6）、其他运算符：包括条件运算符和instanceof 运算符。

2、算术运算符

Java支持的算术运算符如下表所示：

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
--	自减: 操作数的值减少1	B-- 或 --B 等于 19

注意事项：

（1）、自增与自减有两种写法：前缀自增自减法+后缀自增自减法，不同的写法在表达式当中有区别；

（2）、前缀自增自减法：会优先进行自增或自减运算，然后再进行表达式的其他运算；

（3）、后缀自增自减法：会优先进行表达式的其他运算，再进行自增或自减运算；

public class selfAddMinus{
    public static void main(String[] args){
        int a = 1;
        int b = 1;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

运算结果：

自增运算符前缀运算后a=2,x=4；

自增运算符后缀运算后a=2,y=2；

3、关系运算符

Java支持的关系运算符如下表所示：

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

4、位运算符

Java支持的位运算符如下表所示：

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
\|	如果相对应位都是 0，则结果为 0，否则为 1	（A \| B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

注意事项：

（1）、位运算符的应用数据范围有限，只可用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型；

5、逻辑运算符

Java支持的逻辑运算符如下表所示：

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\| \|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \| \| B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

注意事项：

（1）、逻辑与运算符又称短路逻辑运算符，即当你使用逻辑与运算符时，如果第一个判断的结果为false，其结果就必定为false，它就不会再执行后续判断操作；

6、赋值运算符

Java支持的赋值运算符如下表所示：

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	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

7、条件运算符

又称三元运算符。该运算符有三个操作数，并且需要判断布尔表达式的值，并由这个值来决定变量得到哪一个赋值。

public class Test {
   public static void main(String[] args){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
      b = (a == 10) ? 20 : 30;
      System.out.println( "Value of b is : " + b );
   }
}

运行结果：

Value of b is : 30

Value of b is : 20

8、instanceof 运算符

基本概念：该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。

instanceof运算符使用格式如下：

( Object reference variable ) instanceof  (class/interface type)

如果被比较的对象兼容于右侧类型，该运算符仍然返回 true。

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

允许结果：true

9、Java运算符优先级

当多个运算符出现在用一个表达式中时，编译器就会按照优先级的高低排序后执行，因为复杂表达式如果没有统一的执行顺序，得到的结果也会各不相同，java规定的运算符优先级如下表所示：

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr--	从左到右
一元	++expr --expr + - ～！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	> >= < <=	左到右
相等	== !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	\|	左到右
逻辑与	&&	左到右
逻辑或	\| \|	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = \| =	从右到左
逗号	，	左到右