JavaSE学习笔记

最新推荐文章于 2024-04-19 19:12:13 发布

每天仰望30秒，脖子啥病都没有

最新推荐文章于 2024-04-19 19:12:13 发布

阅读量1k

点赞数 1

分类专栏： Java学习笔记

本文链接：https://blog.csdn.net/adad3/article/details/105940926

版权

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

第二章数据类型转换

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

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

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

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

第三章运算符

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

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

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

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

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

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

3.4.5、三元运算符

三元运算符（练习文件Demo10Operator)：
- 一元运算符：只需要一个数据就可以进行操作的运算符，如：取反！；自增++࿱

最低0.47元/天解锁文章

每天仰望30秒，脖子啥病都没有

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
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 ...
复制链接

扫一扫