我家小花儿

这个屌丝很懒，什么也没留下！

热门标签

JavaSE学习笔记

作者：我家小花儿 | 2024-05-24 01:27:44

踩

JavaSE学习笔记

JavaSE

第一章 JavaSE基础

1.1、十进制与二进制的相互转换

十进制转二进制：

除2 以15为例
2/15 余数
2/7 1
2/3 1
2/1 1
0 1 从下往上读为：1 1 1 1

二进制转十进制：乘以二的幂指数以1 1 1 1为例
1 1 1 1 二进制为从右向左读

x x x x

2^3 2^2 2^1 2^0

8 + 4 + 2 + 1 = 15

位（bit）：一个数字0或1，代表一位
字节（Byte）：每逢8位是一个字节，数据存储单元最小的单位，只有整数，没有0.几
1 Byte=8 bit

1.2、Java各工具关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-32HIVq8d-1588690352150)(JavaSE.assets/Java工具关系.png)]

注意：添加注释或中文后需用指定编码编译：javac -encoding “utf-8” +文件名.java

1.3、关键字

关键字特点：

完全小写的英文字母
在增强版的记事本中（如notepad++）有特殊颜色

1.4、标识符

标识符是指在程序中，我们自己定义内容，比如类名字、方法的名字和变量的名字等等，都是标识符。
HelloWorld案例中，出现的标识符有类名字HelloWorld
命名规则（硬性要求，若不遵守必会报错）
- 标识符可以包含【英文26个字母（区分大小写）】【数字0-9】【$（美元符号）】【_（下划线）】
- 标识符不能以数字开头。
- 标识符不能是关键字
命名规范（软性建议）
- 类名规范：首字母大写，后面每个单词首字母大写（驼峰式）
- 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）
- 方法名规范：同变量名

1.5、常量

常量是指在程序运行期间固定不变的量(练习文件Demo01Const.java)
常量的分类：
- 字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如：“abc”，“Hello”，“123”
- 整数常量：直接写上的数字，没有小数点，如：100，200，0，250
- 浮点数常量，直接写上的数字，有小数点，如：2.5，-3.14，0.0
- 字符常量：凡是用单引号引起来的单个字符，叫做字符常量，如：‘A’,‘B’,‘9’,‘中’
- 布尔常量：只有两种取值：true，false
- 空常量：null，代表没有任何数据

Demo01Const.java

public class Demo01Const {
	public static void main(String[] args) {
		//字符串常量
		System.out.println("ABC");
		System.out.println("");//字符串两个双引号中间的内容为空
		System.out.println("XYZ");
		
		//整数常量
		System.out.println(30);
		System.out.println(-500);
		
		//浮点数常量(小数)
		System.out.println(3.14);
		System.out.println(-2.5);
		
		//字符常量
		System.out.println('A');
		System.out.println('6');
		System.out.println(' ');//两个单引号中间必须有且仅有一个字符，没有不行/有俩也不行
		
		//布尔常量
		System.out.println(true);
		System.out.println(false);
		
		//空常量，空常量不能直接用来打印输出。
		System.out.println(null);
	}
}
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.1、数据类型

注意事项：

字符串不是基本类型，而是引用类型
浮点型可能只是一个近似值，并非精确的值
数据范围与字节数不一定相关，例如float数据范围比long更广泛，但是float是4字节，long是8字节
浮点数当中默认类型是double，如果一定要使用float类型，需要加一个后缀F
如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L，推荐是用大写字母后缀/System.out.println(100L);/

2.1.1、基本数据类型（四类八种）

数据类型	关键字	内存占用
整数型	byte（字节型）	1个字节	-128~127
	short （短整型）	2个字节	-32768~32767
	int（短整型）（默认）	4个字节	-2的32次方~2的32次方-1
	long（长整型）	8个字节	-2的63次方~2的63次方-1
浮点型	float（单精度）	4个字节	1.4013E-45~3.4028E+38（E表示为乘以10的+38/-45次方）（科学计数法）
	double（双精度）（默认/更为精确）	8个字节	4.9E-324~1.7977E+308
字符型	char（字符型）	2个字节	0~65535
布尔型	boolean（布尔类型）	1个字节	true，false

2.1.2、引用数据类型（后面学）

字符串，数组，类，接口，lambda

2.2、变量

程序运行期间，内容可以发生改变的量（两种格式）（练习文件Demo02Variable.java）

创建一个变量并且使用的格式：

数据类型变量名称； //创建了一个变量
变量名称 = 数据值；//=代表赋值，将右边的数据值赋值交给左边的变量
数据类型变量名称 = 数据值；// 在创建一个变量的同时，立刻放入指定的数据值（一步到位，合二为一）
注意事项:
1. 如果创建多个变量,那么变量之间的名称不可以重复
2. 使用float/long类型，需要加一个后缀F/L
3. 使用byte/short类型的变量,右侧数值的范围不能超过左侧数据类型的取值范围
4. 没有进行赋值的变量,不能直接使用;一定要赋值之后,才能使用
5. 变量使用不能超过作用域的范围（程序执行是从上至下的，在创建变量之前不能使用变量）
  【作用域】：从定义变量的一行开始，一直到直接所属的大括号{}结束为止
6. 可以通过一个语句来创建多个变量，但是一般情况不推荐这么写

Demo02Variable.java

//变量；程序运行期间，内容可以发生改变的量（两种格式）（练习文件Demo02Const.java）
	//创建一个变量并且使用的格式：
	//1.数据类型 变量名称； //创建了一个变量
	  //变量名称 = 数据值；//=代表赋值，将右边的数据值赋值交给左边的变量
	//2.数据类型 变量名称 = 数据值；// 在创建一个变量的同时，立刻放入指定的数据值（一步到位，合二为一）
public class Demo02Variable{
	public static void main(String[] args){		
		int num1;		//创建了一个变量,格式;数据类型 变量名称;
		num1 = 10;		//相变量当中存入一个数据;格式:变量名称 = 数据值；
		System.out.println(num1);		//打印输出变量名称的时候,显示出来的是变量的内容
		
		//改变变量中本来的数字,变成新的数字
		num1 = 20;
		System.out.println(num1);
		
		//使用一步到位的格式定义变量
		//格式:数据类型 变量名称 = 数据值；
		int num2 = 25;
		System.out.println(num2);
		
		num2 = 35;
		System.out.println(num2);
		System.out.println("<========华丽的分割线========>");
		
		byte num3 = 30; //注意;右侧数值的范围不能超过左侧数据类型的取值范围
		//byte num3 = 400; //右侧超出了byte数据范围,报错!
		System.out.println(num3);
		
		short num5 = 50;
		System.out.println(num5);
		
		long num6 = 3000000000L; //注意!使用long类型，需要加上一个后缀L
		System.out.println(num6);
		
		float num7 = 2.5F; //注意!使用float类型，需要加一个后缀F
		System.out.println(num7);
		
		double num8 = 1.2;
		System.out.println(num8);
		
		char zifu1 = 'A';
		System.out.println(zifu1);
		
		zifu1 = '中';
		System.out.println(zifu1);
		
		boolean var1 = true;
		System.out.println(var1);
		
		var1 = false;
		System.out.println(var1);
		
		//将一个变量的数据内容,赋值交给另一个变量
		//右侧的变量名称var1已经存在,里面装的是false布尔值
		//将右侧变量里面的false值,向左交给var2变量进行存储
		boolean var2 = var1;
		System.out.println(var2);
	}
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

2.3、数据类型

当数据类型不一样是，将会发生数据类型转换

2.3.1、自动类型转换

自动类型转换（隐式）（练习文件Demo01DataType.java）
特点：代码不需要进行特殊处理，自动完成
规则：数据范围从小到大（与字节数不一定相关，与取值范围有关）
int–>long，符合了数据范围从小到大的要求，发生了自动转换

Demo01DataType.java

public class Demo01DataType{
	public static void main(String[] args){
			System.out.println(1024); //这就是一个整数，默认是int类型
			System.out.println(3.14); //这就是一个浮点数，默认是double类型
			
			//左边是long类型，右边是默认的int类型，左右不一样
			//一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储
			//int-->long，符合；了数据范围从小到大的要求
			//这一行代码发生了自动类型转换
			long num1 = 100;
			System.out.println(num1);
			
			//左边是double类型，右边是float类型，左右不一样
			//一个等号代表赋值，将右侧的float常量，交给左侧的double变量进行存储
			//float-->double，符合；了数据范围从小到大的要求
			//这一行代码发生了自动类型转换
			double num2 = 2.5F;
			System.out.println(num2);
			
			//左边是float类型，右边是long类型，左右不一样
			//一个等号代表赋值，将右侧的long常量，交给左侧的float变量进行存储
			//long-->float，符合；了数据范围从小到大的要求
			//这一行代码发生了自动类型转换
			float num3 = 30L;
			System.out.println(num3);
	}
}
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

2.3.2、强制类型转换

强制类型转换（显示）（练习文件Demo02DataType.java）
特点：代码需要进行特殊格式处理，不能自动完成
格式：范围小的类型范围小的变量名 = （范围小的类型）原本范围大的数据；
注意事项：
- 强制类型转换一般不推荐使用，因为有可能发生精度损失，数据溢出
- byte/short/char这三种类型都可以发生数学运算，例如加法“+”
- byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算
- 计算机的底层会用一个数字（二进制）来代表字符A，就是65【65～90为26个大写英文字母（A-Z）；小写字母与大写字母相差24；48~57为数字（0-9）】
- 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
- Boolean（布尔类型）不能发生数据类型转换

Demo02DataType.java

public class Demo02DataType{
	public static void main(String[] args){
		int num = (int)100L;
		System.out.println(num);
		
		//long强制转换成为int类型
		int num2 = (int)6000000000L;
		System.out.println(num2); //1705032704
		
		//double强制转换为int类型
		int num3 = (int) 3.99;
		System.out.println(num3); //输出为3，这并不是四舍五入，所有的小数位都会被舍弃掉
		
		char zifu1 = 'A'; 
		System.out.println(zifu1 + 1); //输出为66，也就是大写字母被当作65进行处理
		//计算机的底层会用一个数字（二进制）来代表字符A，就是65【65～90为26个大写英文字母（A-Z）】
		//一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
		
		byte num4 = 40; //注意：右侧的数值大小不能超过左侧的类型范围
		byte num5 = 50;
		//byte + byte --> int+int --> int
		int result1 = num4 + num5;
		System.out.println(result1); //输出为90
		
		short num6 = 60;
		//byte + short --> int + int --> int
		//int强制转换为short；注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
		short result2 = (short)(num4 + num6);
		System.out.println(result2); //100
	}
}
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
29
30
31

2.4、数字和字符对照表

数字和字符对照表（编码表）（练习文件Demo03DataTypeChar.java）：

ASCII码表：American Standard Code for Information Interchange，美国标准信息交换代码（小表）
Unicode码表：万国码，也是数字和符号的对照关系，开头0~127部分和ASCII完全一样，但是从128开始包含更多字符
48 - ‘0’
65 - ‘A’
97 - ‘a’

Demo03DataTypeChar.java

/*
数字和字符对照表（编码表）：
ASCII码表：American Standard Code for Information Interchange，美国标准信息交换代码（小表）
Unicode码表：万国码，也是数字和符号的对照关系，开头0~127部分和ASCII完全一样，但是从128开始包含更多字符

48 - ‘0’
65 - ‘A'
97 - ‘a’
*/
public class Demo03DataTypeChar{
	public static void main(String[] args){
	char zifu1 = '1';
	System.out.println(zifu1 + 0); //输出为49
	
	char zifu2 = 'A'; //其实底层保存的是65数字
	
	char zifu3 = 'C';
	//左侧是int类型，右边是插入类型
	//char-->int，是从小到大
	//发生自动类型转换
	int num = zifu3;
	System.out.println(zifu1 + 0); //输出为99
	
	char zifu4 = '中';
	System.out.println(zifu5 + 0); //输出为20013
	}
}
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.1、运算符

运算符(练习文件 Demo04Operator.java)：

运算符：进行特定操作的符号，如：+、
表达式：用运算符连起来的式子叫做表达式，如：20+5，a+boolean（布尔类型）
四则运算：

加：+
减：-
乘：*
除：/
取模(取余数):%

首先计算得到表达式的结果,然后再打印输出这个结果
对于一个整数的表达式来说,除法用的是整除,整数除以整数,结果仍是整数,只看商,不看余数
注意事项:1.一旦运算当中有不同类型的数据,那么结果将会是数据类型范围大的那种

Demo04Operator.java

public class Demo04Operator{
	public static void main(String[] args){
		//两个常量之间可以进行数学运算
		System.out.println(20 + 30);
		
		int a = 20;
		int b = 30;
		System.out.println(a - b); //输出为-10
		
		//变量和常量之间可以混合使用
		System.out.println(a * 10); //输出为200
		
		int x = 10;
		int y = 3;
		
		int result1 = x / y;
		System.out.println(result1); //输出为3
		
		int result2 = x % y;
		System.out.println(result2); //余数,模,1
		
		//int + double-->double+double-->double
		double result3 = x + 2.5;
		System.out.println(result3); //输出为12.5
	}
}	
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

3.2、“ + ”的三种常见的用法

四则运算当中的加号“+”常见的三种用法（练习文件Deme05Plus）：

对于数值来说，那就是加法
对于字符char类型来说，在计算之前char会被提升成为int，然后再计算
char类型字符，和int类型数字，之间的对照关系：ASCII、Unicode
对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作
任何数据类型和字符串类型进行连接的时候，结果都会变为字符串
小括号中的东西都会最先执行

Demo05Plus

public class Demo05Plus{
	public static void main(String[] args){
		//字符串类型的变量基本使用
		//数据类型 变量名称 = 数据值；
		String str1 = "Hello";
		System.out.println(str1); //输出为Hello
		
		System.out.println("Hello" + "World"); //输出为HelloWorld

		String str2 = "Java";
		//String + int --> String
		System.out.println(str2 + 20); //输出为Java20
		
		//优先级问题
		//String + int + int --> String + int --> String
		System.out.println(str2 + 20 + 30); //输出为Java2030

		System.out.println(str2 + (20 + 30)); //输出为Java50
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.3、自增自减运算符

自增自减运算符（练习文件Demo06Operator.java）：

自增运算符：++
自减运算符：–
基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式，写在变量名称之前，或者写在变量名称之后，例如：++num；num++
使用方式(练习文件Demo06Operator.java)
- 1.单独使用，不和其他任何操作混合，自己独立成为一个步骤
- 2.混合使用，和其他操作混合，例如与赋值混合，或者与打印操作混合，等
使用区别：
- 1.单独使用的时候前++与后++没有任何区别
- 2.在混合使用的时候，有重大区别：
  - A：如果是前++，那么变量立刻马上+1.然后拿着结果进行使用。【先加后用】
  - B: 如果是后++，那么首先使用变量本来的数值，然后再让变量+1。【先用后加】
注意事项：只有变量才能使用自增、自减运算符，常量不可发生改变，所以不能用。

Demo06Operator.java

public class Demo06Operator{
	public static void main(String[] args){
	int num1 = 10;
	System.out.println(num1); //输出为10
	++num1; //单独使用，前++
	System.out.println(num1); //输出为11
	num1++; //单独使用，后++
	System.out.println(num1); //输出为12
	System.out.println("----------------华丽的分割线----------------");
	
	//与打印操作混合的时候
	int num2 = 20; 
	System.out.println(++num2); //混合使用，先++，变量立刻马上变成21，输出为21
	System.out.println(num2); //输出为21
	System.out.println("----------------华丽的分割线----------------");

	int num3 = 30;
	//混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
	System.out.println(num3++); //输出为30
	System.out.println(num3); //输出为31
	System.out.println("----------------华丽的分割线----------------");
	
	int num4 = 40;
	//和赋值操作混合
	int result1 = --num4; //混合使用，前++，变量立刻马上-1变成39，然后将结果39交给result1变量
	System.out.println(result1); //39
	System.out.println(num4); //39
	System.out.println("----------------华丽的分割线----------------");
	
	int num5 = 50;
	//混合使用，后--，首先把本来的数字50交给result2，然后我自己再-1变成49
	int result2 = num--;
	System.out.println(result2); //50
	System.out.println(num5); //49
	System.out.println("----------------华丽的分割线----------------");
	
	/*过于复杂不推荐使用，代码应以简洁明了为先
	int x = 10;
	int y = 20;
	//11 + 20 = 31
	int result3 = ++x + y--;
	System.out.println(result3); //31
	System.out.println(x); //11
	System.out.println(y); //19
	*/
	}
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

3.4、赋值运算符

赋值运算符分为以下几种

3.4.1、基本赋值运算符

基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。int a = 30

3.4.2、复合赋值运算符

复合赋值运算符(练习文件Demo07Operator.java)：

+=	a += 3	相当于	a = a + 3
-=	b -= 4	相当于	b = b - 4
*=	c *= 5	相当于	c = c * 5
/=	d /= 6	相当于	d = d / 6
%=	e %= 7	相当于	e = e % 7

注意事项：

只有变量才能使用赋值运算符，常量不能进行赋值，不能写在赋值运算符的左边
复合赋值运算符其中隐含了一个强制类型转换

Demo07Operator.java

public class Demo07Operator{
	public static void main(String[] args){
	int a = 10;
	a += 5; //按照公式进行翻译：a = a + 5	a = 10 + 5	a = 15	a本来是10，现在重新赋值得到15
	System.out.println(a); //输出为15
	
	int x = 10;
	x %= 3; //x = x % 3		x = 10 % 3		x = 1		x本来是10，重新赋值为1			
	System.out.println(x); //输出为1
	
	byte num = 30;
	num += 5; //num = num + 5	num = byte + int	num = int + int		num = int	num = (byte)int	
	System.out.println(num); // 输出为35
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.4.3、比较运算符

比较运算符（练习文件Demo08Operator）：

==	比较符号两边数据是否相等，相等结果是true
<	比较符号左边的数据是否小于右边的数据，如果小于结果是true
>	比较符号左边的数据是否大于右边的数据，如果大于结果是true
<=	比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true
>=	比较符号左边的数据是否大于或者等于右边的数据，如果大于结果是true
!=	不等于符号，如果符号两边的数据不相等，结果是true

注意事项：
1. 比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2. 如果进行多次判断，不能连这些。如数学当中的写法：1 < x < 3,程序当中不允许这种写法

Demo08Operator

public class Demo08Operator{
	public static void main(String[] args){
		System.out.println( 10 > 5 ); //true
		int num1 = 10;
		int num2 = 12;
		System.out.println( num1 < num2 ); //true
		System.out.println( num2 >= 100 ); //false
		System.out.println( num1 <= 12 ); //true
		System.out.println( num1 <= 100 ); //true
		
		System.out.println( 10 == 10 ); //true
		System.out.println( 20 != 25 ); //true
		System.out.println( 20 != 20 ); //false
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3.4.4、逻辑运算符

逻辑运算符(练习文件Demo09Logic)：

与（并且）	&&	全都是true，才是true，否则就是false
或（或者）	\|\|	至少一个是true，就是true，全都是false，才是false
非（取反）	！	本来是true，变成false，本来是false，变成true

与“&&”、或“||”，具有短路效果；如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能
注意事项：
- 逻辑运算符只能用于boolean值
- 与、或需要左右各自有一个boolean值，但是取反只要有唯一的一个boolean值即可
- 与、或两种运算符，如果有多个条件，可以连续写
  - 两个条件：条件A && 条件B
  - 多个条件：条件A && 条件B && 条件C

Demo09Logic

public class Demo09Logic{
	public static void main(String[] args){
	System.out.println(true && false); //false
	System.out.println(true && true); //true
	System.out.println(3 < 4 && 10 > 5); //true
	
	System.out.println(true || false); //true
	System.out.println(true || true); //true
	System.out.println(false || false); //false
	
	System.out.println(true); //true
	System.out.println(!true); //false
	
	int a = 10;
	System.out.println(3 > 4 && ++a < 100); //false,3>4已为false，则不执行++a
	System.out.println(a); //10
	
	int b = 20;
	System.out.println(3 < 4 || ++b < 100); //true,3<4已为true，则不执行++b
	System.out.println(b); //20
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.4.5、三元运算符

三元运算符（练习文件Demo10Operator)：
- 一元运算符：只需要一个数据就可以进行操作的运算符，如：取反！；自增++；自减–
- 二元运算符：需要两个数据才可以进行操作的运算符，如：加法+；赋值=
- 三元运算符：需要三个数据才可以进行操作的运算符
- 格式：数据类型变量名称 = 条件判断？表达式A ：表达式B；
- 流程：首先判断条件是否成立：
  - 如果成立为true，那么将表达式A的值赋值给左侧的变量；
  - 如果不成立为false，那么将表达式B的值赋值给左侧的变量；
  - 二者选其一
注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求
2. 三元运算符的结果必须被使用

Demo10Operator

public class Demo10Operator{
	public static void main(String[] args){
	int a = 10;
	int b = 20;
	
	//数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B；
	//判断a > b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一
	int max = a > b ? a : b; //最大的变量
	System.out.println("最大值: " +max); //输出为20
	
	//int result = 3 > 4 ? 2.5 : 10; 错误写法！
	
	System.out.println(a > b ? a : b); //正确写法！
	
	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

第四章方法入门

4.1、方法

方法（练习文件Demo11Method）：
概念：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能，当我们需要这个功能的时候，就可以去调用，这样即实现了代码的复用性，也解决了代码沉余的现象。
定义一个方法的格式：
public static void 方法名称(){
方法体
}
方法体名称的命名规则和变量一样，使用小驼峰
方法体：也就是大括号当中可以包含任意条语句
注意事项：
- 方法定义先后顺序无所谓
- 方法的定义不能产生嵌套包含关系
- 方法定义好之后，不会执行的，如果要想执行，一定要进行方法的【调用】
如何调用方法，格式：

数据类型
方法名称()；

Demo11Method

/*	定义一个方法的格式：
		public static void 方法名称(){
			方法体
		}
		方法体名称的命名规则和变量一样，使用小驼峰
		方法体：也就是大括号当中可以包含任意条语句
*/		
public class Demo11Method{
	public static void main(String[] args){	
		farmer(); //调用农民的方法
		seller(); //调用小商贩的方法
		cook(); //调用厨子的方法
		me(); //调用我的方法
	}
	//小商贩
	public static void seller(){
		System.out.println("运输到农贸市场");	
		System.out.println("抬高价格");
		System.out.println("吆喝");	
		System.out.println("卖给厨子");	
	}
	
	//厨子
	public static void cook(){
		System.out.println("洗菜");
		System.out.println("切菜");	
		System.out.println("炒菜");
		System.out.println("装盘");
	}
	
	//我
	public static void me(){
		System.out.println("吃");	
	}

	//农民	
	public static void farmer(){
		System.out.println("播种");		
		System.out.println("浇水");	
		System.out.println("施肥");	
		System.out.println("除虫");	
		System.out.println("收割");
		System.out.println("卖给小商贩");	
	}
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

4.2、编译器

编译器的两点优化：

在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量，那么编译器javac将会直接将若干个常量表达式计算得到结果。
short result = 5 + 8；//等号右边全是常量，没有任何变量参与运算
编译之后，得到的.class字节码文件当中相当于【直接就是】：
short result = 13；
右侧的常量结果数值，没有超过左侧范围，所以正确
这成为“编译器的常量优化”
注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。如：short result = 5 + a + 8；

4.3、包机制

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间
包语句的语法格式为：

package pk1[. pkg2[. pkg3…]];
一般利用公司域名的倒置作为包名：com.zhang.xxx/com.wang.xxx
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成次功能

import package1[.package2…].(classname|*);

4.4、JavaDoc

注：此节开始所有练习在IDEA进行，文件位置（D:\code\JavaSE\基础语法）

JavaDoc命令是用来生成自己API文档的
JDK8帮助文档https://docs.oracle.com/javase/8/docs/api/
参数信息
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
可以通过命令行生成JavaDoc文档【javadoc -encoding UTF-8 -charset UTF-8 Doc.java】
也可以使用IDEA生成JavaDoc文档：
- 先看一段样例代码:

//: POI/ExportConfig
/** Excel导出项配置
 * @author Mr zhang
 * @version 1.0
 * @since 1.8
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.FIELD })
public @interface ExportConfig {

	/**
	 * @return 表头显示名(如：id字段显示为"编号") 默认为字段名
	 */
	String value() default "field";

	/**
	 * @return 单元格宽度 默认-1(自动计算列宽)
	 */
	short width() default -1;

	/**
	 * 将单元格值进行转换后再导出：<br/>
	 * 目前支持以下几种场景：<br/>
	 * 1. 固定的数值转换为字符串值（如：1代表男，2代表女）<br/>
	 * <b>表达式:</b> "s:1=男,2=女"<br/>
	 * 
	 * 2. 数值对应的值需要查询数据库才能进行映射(实现com.haohuo.util.poi.convert.ExportConvert接口)<br/>
	 * 
	 * @return 默认不启用
	 */
	String convert() default "";

	/**
	 * @return 当前单元格的字体颜色 (默认 HSSFColor.BLACK.index)
	 */
	short color() default HSSFColor.BLACK.index;

	/**
	 * 将单元格的值替换为当前配置的值：<br/>
	 * 应用场景: <br/>
	 * 密码字段导出为："******"
	 * 
	 * @return 默认true
	 */
	String replace() default "";
}///:~  

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

常用的注解及其作用：
首先规则：以//: 开始，以///:~结束。
- @author 作者名
- @version 版本号
- @since 指明需要最早使用的jdk版本
当然还有一些其他注解，例如在类的方法上：
- @param 参数名
- @return 返回值情况
- @throws 异常抛出情况
第一步

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KM4q3tjI-1588690352155)(JavaSE.assets/（1）-1587978307833.png)]

第二步

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xUYqDcjT-1588690352158)(JavaSE.assets/（2）.png)]

选择是整个项目还是模块还是单个文件
文档输出路径
Locale 选择地区，这个决定了文档的语言，中文就是zh_CN
传入JavaDoc的参数，一般这样写 -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” http://docs.Oracle.com/javase/7/docs/api

第五章 Java流程控制

5.1、用户交互Scanner

5.1.1、Scanner对象

之前所学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了一个工具类，我们可以获取用户的输入。java.util.Scanner是Java5的新特征，我们可以通过Scanner类来获取用户的输入
基本语法：Scanner s = new Scanner(System.in);
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取我们一般需要使用hasNextLine()判断是否还有输入的数据

5.1.2、两种方法

next() 方法
- 一定要读取到有效字符后才可以结束输入
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
- next()不能得到带有空格的字符串
- 是以空格作为结束符的

练习文件Demo01

package com.mza.Scanner;

import java.util.Scanner;

/**
 * Created by Leonardo on 2020/4/27.
 */
public class Demo01 {

    public static void main(String[] args) {

        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收：");

        //判断用户有没有输入字符串
        if(scanner.hasNext()){
            //使用next方式接收
            String str = scanner.next();
            System.out.println("输出的内容为："+str);
        }

        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();

    }
}
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

nextLine()方法（用的场景较多）
- 以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符
- 可以获得空白
- 是以Enter作为结束符的

练习文件Demo02

package com.mza.Scanner;

import java.util.Scanner;

/**
 * Created by Leonardo on 2020/4/27.
 */
public class Demo02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //创建一个扫描器对象，用于接收键盘数据
        System.out.println("使用nextLine方法接收：");

        //判断用户有没有输入字符串
        if (scanner.hasNextLine()){
            //使用nextLine接受
            String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }

        //凡是属于IO流的类如果不关闭会一直占用资源，要养成好习惯用完就关掉
        scanner.close();
    }
}
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

练习文件Demo04

package com.mza.Scanner;

import java.util.Scanner;

/**
 * Created by Leonardo on 2020/4/27.
 */
public class Demo04 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        //从键盘接收数据
        int i = 0;
        float f = 0.0f;

        System.out.println("请输入整数：");

        //如果...那么
        //判断用户有没有输入整数数据
        if(scanner.hasNextInt()){
            //接收输入的i
            i = scanner.nextInt();
            System.out.println("整数数据" + i);
        }else{
            System.out.println("输入的不是整数数据！");
        }

        System.out.println("请输入小数：");

        if(scanner.hasNextFloat()){
            //接收输入的i
            f = scanner.nextFloat();
            System.out.println("小数数据" + f);
        }else{
            System.out.println("输入的不是小数数据！");
        }


        scanner.close();
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41

练习文件Demo05//我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果

package com.mza.Scanner;

import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer;

import java.util.Scanner;

/**
 * Created by Leonardo on 2020/4/27.
 */
public class Demo05 {
    public static void main(String[] args) {
        //我们可以输入多个数字，并求其总和与平均数，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果
        Scanner scanner = new Scanner(System.in);

        //和
        double sum = 0;
        //计算输入了多少个数字
        int m = 0;

        //通过循环判断是否还有输入，并在里面对每一次进行求和和统计
        while (scanner.hasNextDouble()){
            double x = scanner.nextDouble();
            m = m + 1;   //m++
            sum = sum + x;
            System.out.println("你输入了第" + m + "个数据，然后当前结果sum=" + sum);
        }

        System.out.println(m + "个数的和为" + sum);
        System.out.println(m + "个数的平均值是" + (sum / m));

        scanner.close();
    }
}
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
29
30
31
32
33

5.2、顺序结构

Java的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行
顺序结构是最简单的算法结构
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构

练习文件SequenceDemo

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/27.
 * 顺序结构
 */
public class SequenceDemo {
    public static void main(String[] args) {
        System.out.println("hello1");
        System.out.println("hello2");
        System.out.println("hello3");
        System.out.println("hello4");
        System.out.println("hello5");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5.3、选择结构*

5.3.1、if单选择结构

我们很多时候需要去判断一个东西是否可行，然后我们才去执行，这样一个过程在程序中用if语句来表示
语法：

if(布尔表达式){
    //如果布尔表达式为true将执行的语句
}
1
2
3

练习文件IfDemo01

package com.mza.struct;

import java.util.Scanner;

/**
 * Created by Leonardo on 2020/4/27.
 */
public class IfDemo01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入内容");
        String s = scanner.nextLine();

        //equals：判断字符串是否相等
        if (s.equals("Hello")){
            System.out.println(s);
        }

        System.out.println("End");
        scanner.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5.3.2、if双选择结构

公司现在有个需求，公司要收购一个软件，成功了，给人支付100万元，失败了，自己找人开发。这样的需求单用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构
语法：

if(布尔表达式){
    //如果布尔表达式的值为true
}else{
    //如果布尔表达式的值为false
}
1
2
3
4
5

练习文件IfDemo02//考试分数大于60就是及格，小于60就不及格

package com.mza.struct;

import java.util.Scanner;

/**
 * Created by Leonardo on 2020/4/27.
 */
public class IfDemo02 {
    public static void main(String[] args) {
        //考试分数大于60就是及格，小于60就不及格
        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if(score>=60){
            System.out.println("恭喜，您的成绩及格！");
        }else{
            System.out.println("很遗憾，您的成绩不及格");
        }

        scanner.close();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.3.3、if多选择结构

我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD多种情况，存在区间多级判断。比如90-100就是A，80-90就是B…等，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题
语法：

if(布尔表达式1){
    //如果布尔表达式1的值为true执行代码
}else if(布尔表达式2){
    //如果布尔表达式2的值为true执行代码
}else if(布尔表达式3){
    //如果布尔表达式3的值为true执行代码
}else{
    //如果以上布尔表达式的值都不为true执行代码
}
1
2
3
4
5
6
7
8
9

注意：
- if语句至多有1个else语句，else语句在所有的else if语句之后
- if语句可以有若干个else if语句，它们必须在else语句之前
- 一旦其中一个else if语句检测为true，其它的else if已经else语句都将跳过执行

练习文件IfDemo03//对各等级考试分数的判断

package com.mza.struct;

import java.util.Scanner;

/**
 * Created by Leonardo on 2020/4/27.
 */
public class IfDemo03 {
    public static void main(String[] args) {
        //对各等级考试分数的判断
        Scanner scanner = new Scanner(System.in);

        /**
         * if语句至多有1个else语句，else语句在所有的else if语句之后
         * if语句可以有若干个else if语句，它们必须在else语句之前
         * 一旦其中一个else if语句检测为true，其它的else if已经else语句都将跳过执行
         */

        System.out.println("请输入成绩：");
        int score = scanner.nextInt();

        if (score==100){
            System.out.println("恭喜，成绩满分！");
        }else if (score < 100 && score >= 90){
            System.out.println("优秀");
        } else if(score < 90 && score >= 80){
            System.out.println("良好");
        } else if(score < 80 && score >= 70){
            System.out.println("良");
        } else if(score < 70 && score >= 60){
            System.out.println("及格");
        } else if(score < 60 && score >= 0){
            System.out.println("不及格");
        } else { //单独处理边界外不合理的情况
            System.out.println("数据输入错误");
        }

        scanner.close();
    }
}
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
29
30
31
32
33
34
35
36
37
38
39
40

5.3.4、嵌套的if结构

使用嵌套的if…else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if或者if else语句。你可以像if语句一样嵌套else if…else
语法：

if(布尔表达式1){
    //如果布尔表达式1的值为true执行代码
    if(布尔表达式2){
        //如果布尔表达式2的值为true执行代码
    }
}
1
2
3
4
5
6

思考：我们需要寻找一个数，在1-100之间

5.3.5、switch多选择结构

多选择结构还有一个实现方式就是switch case语句
switch case语句来判断一个变量与一系列值中某个值是否相等，每个值称为一个分支
switch语句中的变量类型可以是
- byte、short、int或者char
- JDK7的新特性，表达式结果可以是字符串
- JavaSE7开始，switch支持字符串String类型了
- 同时case标签必须为字符串常量或字面量
语法

switch(expression){
    case value:
        //语句
        break;   //可选(最好写上)
    case value:
        //语句
        break;   //可选(最好写上)
        //你可以有任意数量的case语句
    default:   //可选
        //语句
}
1
2
3
4
5
6
7
8
9
10
11

练习文件SwitchDemo01

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/28.
 */
public class SwitchDemo01 {
    public static void main(String[] args) {
        //case穿透   //switch匹配一个具体的值
        char grade = 'C';

        switch(grade){
            case 'A':
                System.out.println("优秀");
                break;   //可选
            case 'B':
                System.out.println("良好");
                break;
            case 'C':
                System.out.println("及格");
                break;
            case 'D':
                System.out.println("再接再厉");
                break;
            case 'E':
                System.out.println("挂科");
                break;
            default:
                System.out.println("未知等级");
        }
    }
}
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
29
30
31

练习文件SwitchDemo02

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/28.
 */
public class SwitchDemo02 {
    public static void main(String[] args) {
        String name = "张三";
        //JDK7的新特性，表达式结果可以是字符串
        //字符的本质还是数字

        //反编译  Java---class（字节码文件）---反编译（IDEA）

        switch(name){
            case"张三":
                System.out.println("张三");
                break;
            case"李四":
                System.out.println("李四");
                break;
            default:
                System.out.println("弄啥嘞！");
        }
    }
}
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

5.4、循环结构

三种主要的循环结构：
- while循环
- do…while循环
- for循环
在Java5中引入了一种主要用于数组的增强型for循环

5.4.1、while循环

while是最基本的循环，它的结构为：

while(布尔表达式){
    //循环内容
}
1
2
3

只要布尔表达式为true，循环节会一直执行下去
我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环
少部分情况需要循环一直执行，比如服务器的请求响应监听等
循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或造成程序卡死崩溃！
思考：计算1+2+3+…+100=？

练习文件WhileDemo01（输出1~100)

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/28.
 */
public class WhileDemo01 {
    public static void main(String[] args) {
        //输出1~100

        int i = 0;

        while(i<100){
            i++;
            System.out.println(i);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

练习文件WhileDemo02（死循环）

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/28.
 */
public class WhileDemo02 {
    public static void main(String[] args) {
        //死循环
        while (true){
            //等待客户端连接
            //定时检查
            //......
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

练习文件WhileDemo03（计算1+2+3+…+100=？）

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/28.
 */
public class WhileDemo03 {
    public static void main(String[] args) {
        //计算1+2+3+...+100=？

        int i = 0;
        int sum = 0;

        while(i<=100){
            sum = sum +i;
            i++;
        }
        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

5.4.2、do…while循环

对于while语句而言，如果不满足条件，则不能进入循环，但有时候我们需要即使不满足条件，也至少执行一次
do…while循环和while循环相似，不同的是，do…while循环至少会执行一次
while和do…while的区别：
- while先判断后执行。do…while是先执行后判断
- do…while总是保证循环体会被至少执行一次，这是它们的主要差别
语法：

do{
    //代码语句
}while(布尔表达式);
1
2
3

练习文件DoWhileDemo01

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/28.
 */
public class DoWhileDemo01 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;

        do {
            sum = sum + i;
            i++;
        }while (i<=100);

        System.out.println(sum);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

练习文件DoWhileDemo02

package com.mza.struct;

/**
 * Created by Leonardo on 2020/4/28.
 */
public class DoWhileDemo02 {
    public static void main(String[] args) {
        int a = 0;
        while (a<0){
            System.out.println(a);
            a++;
        }
        System.out.println("============华丽的分割线=============");
        do {
            System.out.println(a);
            a++;
        }while ( a < 0 );
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

JavaSE学习笔记

JavaSE

第一章 JavaSE基础

1.1、十进制与二进制的相互转换

1.2、Java各工具关系

1.3、关键字

1.4、标识符

1.5、常量

第二章 数据类型转换

2.1、数据类型

2.1.1、基本数据类型（四类八种）

2.1.2、引用数据类型（后面学）

2.2、变量

2.3、数据类型

2.3.1、自动类型转换

2.3.2、强制类型转换

2.4、数字和字符对照表

第三章 运算符

3.1、运算符

3.2、“ + ”的三种常见的用法

3.3、自增自减运算符

3.4、赋值运算符

3.4.1、基本赋值运算符

3.4.2、复合赋值运算符

3.4.3、比较运算符

3.4.4、逻辑运算符

3.4.5、三元运算符

第四章 方法入门

4.1、方法

4.2、编译器

4.3、包机制

4.4、JavaDoc

注：此节开始所有练习在IDEA进行，文件位置（D:\code\JavaSE\基础语法）

第五章 Java流程控制

5.1、用户交互Scanner

5.1.1、Scanner对象

5.1.2、两种方法

5.2、顺序结构

5.3、选择结构*

5.3.1、if单选择结构

5.3.2、if双选择结构

5.3.3、if多选择结构

5.3.4、嵌套的if结构

5.3.5、switch多选择结构

5.4、循环结构

5.4.1、while循环

5.4.2、do…while循环

5.4.3、For循环声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/615162

第二章数据类型转换

第三章运算符

第四章方法入门