JavaSE基础知识（未完待续）

JavaSE基础知识回顾：

1 Java入门知识

1.1 就业方向

JavaSE -》 JavaEE 大数据 安卓。它们三个中，JavaSE都是基石；

1.2 Java语言特性

• 面向对象；
• 语言健壮，强类型、异常机制、垃圾回收；
• 跨平台，class在jvm的基础之上可以实现跨平台的性质。jvm是一台虚拟的计算机，全称 Java Virtual Machine，它包含自己的指令集、模块化的存储空间；
• 解释型语言，编译之后需要解释器再包一层才能被操作系统所识别。但是C/C++都是编译型语言，经过特定编译器编译之后操作系统可以直接执行；

1.3 JDK和JRE及JVM

• JDK = JRE + java javac javadoc javap [ java development kit Java开发工具包]
• JRE = JVM + Java核心类库[java running environment Java运行时环境]

如果只想运行开发好的Java程序只需要安装JRE即可；

JDK安装逻辑：

新建系统变量JAVA_HOME，这里面的路径存放JDK的安装目录，不需要bin；

然后在path中新建一行记录，%JAVA_HOME%\bin，最终就可以完成配置了；

技术学习思路：先确定需求 -> 现有能否解决，缺点如何。利用旧技术做类比理解，然后思考出我们为什么使用新技术，最好使用哪个新技术，为什么在这里多的新技术中偏偏选用了它 -> 思考前面的点之后，我们就可以做到明确学习目标 -> 学习基本语法（但绝不追求细节） -> 做出一个Demo -> 研究技术的注意事项、使用细节、使用规范、如何优化。永无止境；

1.4 转义字符

核心就是 \；

// 1. 制表位 \t
System.out.println("Test\tsay\tHello");
// 2. 换行符 \n
System.out.println("Hello\nWorld!");
// 3. 转义符 \
System.out.println("\\");
// 4. 输出 " 字符
System.out.println("\"\"");
// 5. 回车符 \r：把该行光标回退到行首，然后继续输入。会产生替换字符的作用
System.out.println("Lmj Love Mjh \r\n2799");
1
2
3
4
5
6
7
8
9
10

1.5 comment注释

好习惯，多写注释；

单行注释：//

多行注释：/**/，多行注释中不能嵌套使用；

文档注释：/** * * * */，javadoc -d 路径 -标签名 -… -… XXX.java

1.6 代码规范

1. 类和方法的注释要用 javadoc 的形式来完成；
2. 非 javadoc 形式的注释是写给维护者或者阅读者来看的，着重告诉读者为什么这样写，修改时的注意事项；
3. 运算符和 = 号前后各加一个空格；
4. 源文件要使用 utf-8 编码；
5. 一行代码不要超过 80 个字符；
6. 行尾风格 test() { ，次行风格 test() \n {}；

1.7 常用 dos 命令

dos == Disk Operating System 磁盘操作系统，因为里面的主要部分就是各种文件的路径；

dir 显示当前路径下的所有文件（文件夹就是目录) ，也可以指定目录进行展示；

cd /d c:\ 进入 C 盘（changer directory）；

相对和绝对路径：

相对：从当前目录开始定位。…\ 跳到上一级文件夹；

绝对：从根目录开始定位（通常我们给定的 绝对路径 都是从根盘符开始出发的）；

tree 后跟路径名；

cls 清屏[苍老师]；

md make directory ；

rd 删除目录；

del 删除文件；

echo 字符串 > 文件名.后缀（可以创建出一个包含所给定字符串的 文件）；

type nul > 文件名.后缀（可以创建出一个空文件）；

copy fileName pathName；（复制）

move fileName pathName ;（剪切）

在使用 CMD 运行 javac 及 java 命令的时候通常会遇到乱码的问题，因为 CMD 窗口的编码集是 GBK ，而文件通常使用的是 UTF-8 。
    解决方案：javac -encoding utf-8 Test.java 然后再使用 java Test 就不会产生乱码了；
    还可以使用 javac -encoding utf-8 Test.java java -Dfile-encoding=utf-8 Test ，虽然后者没啥卵用，但是还是要积累一下的；
1
2
3

2 Java变量及数据类型

变量三要素：类型、名称、值；

数据类型分为：引用类型、基本类型；

引用类型：数组、类、接口；

基本类型：byte[1] boolean[1] char[2] short[2] int[4] long[8] float[4] double[8]；

整形：byte[1] short[2] int[4] long[8]。default int；

浮点型：float[4] double[8]。default double；

浮点数 = 符号位 + 指数位 + 尾数位，并且浮点数都是近似值；

布尔型：boolean[1]；

字符型：char[2]；

2.1 浮点数细节

1 浮点数由三部分组成：符号位 指数位 尾数位，因为尾数位可能会有丢失，所以小数都是近似值；

2 如果我们想给双精度赋一个 0.518 ，那此时我们只需要写 double d1 = .518即可，因为它会自动为我们前缀0；

3 针对浮点数的表示形式可以采用两种，分别是十进制形式，如 double d2 = 1.24 ，但是我们还可以采用科学计数法的形式，如 double d3 = 124E-2，通常的话，正幂用小e，负幂用大E；

4 尽量不要用结果为浮点数的数字与其他数字进行 等等 操作，因为这样的逻辑我们是不可控的。如果非用不可，我们可以这样来考虑，利用两数相减结果值的绝对值判断它是否处在某个区间内来完成业务逻辑。比如 8.1 / 3 ，这个可以很明显的看出计算机的计算精度问题；

2.2 包的组织形式

包中包含 接口、类、异常、错误、枚举，而每个类中又包含 字段、构造方法、成员方法；

2.3 字符细节

1. 字符只能使用单引号；
2. 允许把转义字符赋给 char 类型的变量；
3. char 的本质是一个数字，它默认的输出是 Unicode 编码对应的字符，如果我们想输出 char 对应的 Unicode 编码，需要加 (int) 进行强转；
4. 字符型变量存储的过程：字符 -> 十进制 Unicode 码 -> 二进制 -> 内存存储。提取过程：二进制 -> 十进制 Unicode -> 字符；
5. 字符和码值是通过编码表决定的，人为规定的内容；

各类编码介绍：

ASCⅡ：美国人的编码格式，占 1 个字节，但实际只使用了 128 位，虽然 1 个可以存储 256 位；

Unicode：任何字符都占两个字节。结果是很浪费空间；

UTF-8：英文占 1 个，中文占 3 个；

GBK：英文占 1 个，中文占 2 个；

GB2312：也可以表示汉字，但是范围要比GBK要小；

BIG5：中文繁体，台湾 香港用的多；

2.4 数据类型运算转换

2.4.1 转换规则

当在进行运算的时候，精度小的类型自动转换为精度大的数据类型；

char -> int -> long -> float -> double
byte -> short -> int -> long -> float -> double
1
2

2.4.2 转换要点

下面所有数据如果没有注明类型，那默认就是基本类型英文的首字母；
1 有多种数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算；
	double num1 = b1 + s1 + i1 + f1 + d1; √
	float num1 = b1 + s1 + i1 + f1 + d1; ×
2 把精度大的赋值给精度小的会报错，反之则自动转换；
	d1 = f1; √
	f1 = d1; ×
3 byte short 它们俩和 char 之间不会互相自动转换；
	1 首先 byte 和 short 是有符号的数字，而 char 是无符号的。所以从这点上来说，就没办法转换；
		* byte [ -128 , 127 ]
		* short [ -32768 , 32767 ]
		* char [ 0 , 65535 ] 因为无符号，给负值就报错；
4 byte short char 三个可以混合运算，也可以混合参与到其他运算中。运算时自动转为 int 
	i1 = b1 + s1 + c1;
	因为， b s 它们俩和 c 不能互相转，所以它们就必须通过一个中介来解决这个问题。所以 Java 中就选用了 int 作为这个中介来解决 b s c 之间的数值运算；
5 boolean 不参与转换；
	boolean bo1 = true;
	i1 = b1 + bo1;
	error-log:
		AutoConvertDetails.java:37: 错误: 二元运算符 '+' 的操作数类型错误
                i1 = b1 + bo1;
                        ^
                  第一个类型:  byte
                  第二个类型: boolean
                  1 个错误
6 自动提升原则，表达式结果自动提升为运算式中精度最大的数据类型；
	num1 = b1 + s1 + i1 + f1 + d1 + c1;
	res 8.199999928474426 。邦邦打脸，结算后期必出问题；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

2.4.3 赋值

byte short char 三个对象赋值的时候，会首先判断是否在自己的可控范围内，如果不在就会报 int 转对应类型的 精度异常。按逻辑应该就是这样，因为 long float double 它们都有自己的限定符号来注明。 int 是默认的，所以它们只能那样搞了；
1

2.4.4 强制类型转换

int i1 = (int) 1.9;
可以是可以，但是造成的精度损失；
byte b1 = (byte) 1000;
可以是可以，但是造成了数据溢出。这样结果是不可控的；
强转符号只针对于最近的操作数字；
int x = (int)10 * 3.5 + 6 * 1.5;
直接报错，因为结果是 double ；
int x = (int)(10 * 3.5 + 6 * 1.5);
结果正确；

重要结论：只要有 byte short char 参与的数值运算且算式中的变量精度没超过 int 的，结果都会自动转为 int ；
				s1 = s1 + 1;
		b1 = b1 + 1;
	
		b1 = b1 + b1;
		s1 = s1 + s1;
		
		s1 = b1 + s1;
		b1 = b1 + s1;
		
		c1 = c1 + 1;
		c1 = c1 + c1;
		
		c1 = b1 + c1;
		c1 = s1 + c1;
		c1 = b1 + s1 + c1;
		以上算式全错；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3 运算符

3.1 算术运算符

+、-、*、/、%、++、--；
++i和i++，前者先加再用，后者先用再加；
1
2

3.1.1 算术运算符的性质

1 模运算（a - a / b * b）|| (a - (int)a / b * b)

%：模运算，就是求一个出发的余数。当分子大于分母时，余数肯定为 0 ，所以模运算也是 0 ；
模运算本质公式：a % b = a - a / b * b；

10 % 3 = 10 - (10 / 3) * 3 = 10 - 3 * 3 = 1；结果正确；
10 % -3 = 10 - (10 / -3) * -3 = 10 - (-3 * -3) = 1；结果正确；
-10 % 3 = -10 - (-10 / 3) * 3 = -10 - (-3 * 3) = -1；结果正确；
-10 % -3 = -10 - (-10 / -3) * -3 = -10 - (3 * -3) = -1；结果正确；
总结：取余运算结果值的符号跟随 前者 ；
1
2
3
4
5

2 自增自减运算（临时空间tmp）

具备自动强转;
前加加：
int i = 1;
int j = ++i; -> j == 2;
后加加：
int k = 1;
int m = k++; -> m == 1;
如果自增运算单独使用，那么前加加和后加加是一致的。但是如果两个参与了运算式的运算，就会有所区分了；
自减运算的逻辑和自增是一致的；

# 经典面试题（创建临时空间）
int i1 = 1;
int j = ++i1;
System.out.println(j); // 2 -> i = i + 1; tmp = i; j = tmp;
int k = i1++;
System.out.println(k); // 1 -> tmp = i; i = i + 1; k = tmp;
System.out.println(i1);
// 这个时候新建了一个 临时空间 tmp ，但是上面的会创建吗？视频中只说了下面的情况
int i2 = 1;
i2 = ++i2; // 2 i2 = i2 + 1; tmp = i2; i2 = tmp;
System.out.println(i2); 
int i3 = 1;
i3 = i3++; // 1 -> tmp = i3; i3 = i3 + 1; i3 = tmp;
System.out.println(i3); 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3.2 关系运算符

==、!=、>、<、>=、<=；
instanceof：判断否则对应是否为某个类的对象。"mjh" instanceof String : res true ；
1
2

3.3 逻辑运算符

1 短路与 && ，短路或 || ， 取反 ! ；
2 与符 & ，或符 | ，异或符 ^ ；
1
2

3.4 赋值运算符

=：自右向左。延伸有：+= -= *= /= %=（这些都具备自动强转）；
1 赋值运算的左边只能是变量，右边可以是 变量 表达式 常量；
2 复合赋值运算符会进行类型转换；byte b; b += 1; 这里进行了强制类型转换；*****
1
2
3

3.5 三元运算符

条件表达式 ? res-1 : res-2;
三元表达式中，res-1 和 res-2 和接收变量的类型一定要是可以匹配的，也就是说这里可能会有自动类型转换，或者是手动的强制类型转换；
1
2

3.6 各种运算符的优先级及计算方向问题

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gzToVIIH-1667133216281)(typoraImages/运算符优先级.jpg)]

1 优先级

1 () {} , ; .
2 单目运算符 ++ -- !
3 算术运算符 + - * / %
4 位运算 & | ^ ~ >> << >>>
5 比较运算符 > = < >= <= != 
6 逻辑运算符 && || & | ! ^
7 三目运算符 ? :
8 赋值运算符 = += -+ *= /= %=
1
2
3
4
5
6
7
8

2 计算方向

除 单目运算符及赋值运算符 为 自右向左 外，其他所有的运算符都是 自左向右 的；

4 标识符

标识符的含义：凡是需要起名字的地方都是标识符。Java缔造者已经早就了许多标识符，这些标识符名为关键字和保留字；

4.1 标识符的命名规则

1 只能由 26 个英文字母大小写、0-9、 _ 、 $ 组成；
2 数字不能开头；
3 不可以使用关键字和保留字；
4 Java中严格区分大小写；
5 标识符不能包含空格；
1
2
3
4
5

5 进制

二进制：以 0b或者0B 开头；
八进制：以 0 开头；
十进制：正常开头；
十六进制：以 0x或者0X 开头，包含0到9及a或A（10）- f或F（15）；

5.1 进制的互相转换

二、八、十六转十；
十转二、八、十六；
八、十六转二；
二转八、十六；

5.2 位运算

1 Java中是不存在无符号数的；
2 所有计算过程都是采用补码进行的；
3 所有结果的读取都是采用源码进行的；
4 总共七个位运算：

& 与运算。同1则1；
| 或运算。有1则1；
^ 异或运算。不同为1；
~ 按位取反运算。1为0，0为1；
>> 算术右移，符号位不变，正数左补0，负数左补1；
<< 算术左移，符号位不变，右补0；
>>> 无符号右移，符号位跟随移动，左补0；
1
2
3
4
5
6
7

6 控制语句

控制语句总的分为三种：顺序控制、分支控制、循环控制；

6.1 顺序控制

从上到下依次执行，执行过程中没有任何判断和跳转；

6.2 分支控制

6.2.1 if-else：

1 单分支：if
2 双分支：if-else
3 多分支：if-else if-else

多分支特点：
1 在多分支表达式中，只能有一个程序执行入口。如果所有 if、else-if 都不满足，就会自动执行 else 语句；
2 多分支可以没有 else 语句，此时可能存在的一种情况，就是多分支情况下没有程序入口；

6.2.2 switch

语法：
switch ( 表达式 ){ // 表达式的结果是一个 常量值;

case 常量 1 : 代码块1 break;
case 常量 2 : 代码块2 break;
…;
default : default代码块 break;

}

switch语句执行流程：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a9a5TQnG-1667133216282)(typoraImages/switch语句流程图.jpg)]

总结一下：它只有遇到 break || default 才会停止执行。而且如果 case 1 没有 break 它就会强制执行 代码块2 ，直到遇到 break || default 才会停止执行；

switch 小细节：

1 表达式中的值应和 case 后的常量类型一致。可以是类型一致，或者是能够进行自动类型转换的，可以理解为 char -> int；
2 switch表达式中的值的类型必须是 byte short int char String 这几种类型；
3 case 子句中的值必须是常量，不能是变量；
4 default 是可选的；
5 break 是用来在执行完一个 case 后跳出 switch 的，当一个 case 后没有 break ，那此时的 case会自动执行到 switch 结尾，而且在执行的过程中是直接执行每个 case || defautlt 中对应的代码块，根本不去判断是否匹配。除非中途遇到的 break ；

6.3 循环控制

6.3.1 for循环

for 的四要素：
1 变量初始化；
2 循环条件；
3 循环操作，循环体中的语句；
4 循环变量迭代；

for 循环执行次序：

初始化语句 -> 判断是否满足循环条件 -> 循环体 -> 循环变量迭代 -> 循环条件判断 -> 循环体 -> 循环变量迭代 -> 循环条件判断 -> 循环体 -> 循环变量迭代；
由此我们可以看出，初始化语句只会执行一次，然后 条件 体 迭代 这三部分就开始循环执行了；

for 循环细节：

1 循环条件必须是一个结果为 boolean 类型的表达式；
2 循环变量初始化和循环变量迭代可以不写，但是循环条件必须要写，而且 ; 循环条件 ; 最少也要保持这种形式；
3 循环变量初始化可以是多条语句，但是要求类型一致，之间使用逗号隔开。循环变量迭代也可以有多个，之间的话也是要使用逗号进行隔开的；
4 循环条件也是可以省略不写的。不写的话就是死循环了；

6.3.2 while循环

一、 语法：

1 循环变量初始化；
2 while( 循环条件 ){

​ 3 循环代码块；
​ 4 循环变量迭代；

}

二、while执行次序

1 循环变量初始化；
2 判断是否满足循环条件;

​ 2.1 满足就执行代码块和变量迭代；
​ 2.2 不满足就退出 while 循环；

3 在进入 while 循环后，每次都会执行代码块和进行循环变量迭代，然后判断是否满足循环条件，满足就继续执行 while ，否则就直接退出 while 循环；

6.3.3 do-while循环

一、语法：

1 循环变量初始化；

do {

​ 2 循环体；
​ 3 循环变量迭代；

4 }while (循环条件) ;

它第一次执行的时候，先执行循环体再判断循环条件。这就导致即使不满足循环条件，我也会执行一次语句。当进入第二次执行的之后，就和正常的 while 及 for 循环逻辑一致了；

6.4 跳转控制语句

6.4.1 break

它的作用是用于退出各种循环控制语句；

使用细节：

1 标签(label)，在各种循环控制语句中，可以使用标签来指定 break 会退出哪层循环；

demo
    label1:
		for (int i = 1; i < 10 ; i++){
            label2:
            for (int j = 1; j < 10; j++){
                if (j == 9){
                    // 退出外层 for 循环；
                    break label1;
                }
            }
        }
1
2
3
4
5
6
7
8
9
10
11

2 实际开发中，尽量不要使用标签。会降低可读性；

3 如果没有指定标签， break 会默认退出离自己最近的循环控制语句；

6.4.2 continue

退出本次循环，它也可以使用标签进行退出操作。退出本次循环之后，直接执行循环条件判断语句；

7 数组

7.1 数组定义的几种方式

1 动态初始化
    int[] arr1 = new int[5]; 或者是 int arr1[] = new int[5]; 但是我们一般倾向于前者，因为变量三要素，数据类型 变量名 值；
2 
1
2
3