Java语言基础

注释

注释在程序中用于解释说明的文字
分类:

单行注释:
	注释当前行内容
多行注释
	注释多行内容
文档注释(暂不涉及)
	注释多行内容,并附上代码的版本,作者,时间等等

格式:

单行注释:
		//注释内容
	多行注释:
		/*
			注释内容
		*/
	文档注释:
		/**
			注释内容
		*/

注意事项:

1.多行注释以/*作为注释的开始,以遇到的第一个*/作为注释的结束
2.文档注释以/**作为注释的开始,以遇到的第一个*/作为注释的结束

关键字

关键字:在程序中被赋予特殊含义的英文单词

特点和注意事项:
	1.关键字一共53个,其中51个是常用关键字,2个保留关键字
	2.关键字必须全部小写
	3.在Editplus软件中关键字的颜色呈"蓝色"
	4.main不是关键字

变量

变量:在程序中其值可以发生改变的量

变量的三要素:
	数据类型
	变量名
	初始化值

变量的声明初始化格式:
	直接声明初始化:
		数据类型 变量名 = 初始化值;
	先声明后初始化:
		数据类型 变量名;
		变量名 = 初始化值;

数据类型

分类:
	基本类型
		整数类型
			byte,short,int(默认),long
		浮点类型
			float,double(默认)
		字符类型
			char
		布尔类型
			boolean
	引用类型
		数组
		类
		接口

整数类型:
	含义:
		用于声明整数数据的数据类型
	特点:
		在程序中每声明一个byte类型变量,占用1字节内存
		在程序中每声明一个short类型变量,占用2字节内存
		在程序中每声明一个int类型变量,占用4字节内存
		在程序中每声明一个long类型变量,占用8字节内存
浮点类型:
	含义:
		用于声明浮点数据的数据类型(浮点可以理解小数,底层并不是十进制的小数)
	特点:
		在程序中每声明一个float类型变量,占用4字节内存
		在程序中每声明一个double类型变量,占用8字节内存
	注意:
		float和double现阶段可以将其当成小数类型进行使用,但是在实际开发中涉及具体数值不可以使用double和float,需要使用精确的小数类型(后面讲解)

字符类型:
	含义:
		用于声明单个字母,数字,汉字等符号的数据类型
	特点:
		在程序中char类型变量存储占用字节数有两套规则:内码和外码
		内码规则:
			由底层源码创建的char类型变量,每个字符占用2个字节
		外码规则:
			由程序员自定义的char类型变量,每个字节占用字节数遵循编码规则
				GBK编码(window简体中文默认码表)
					字母,数字,中文每个字符占用2个字节
				UTF-8编码
					字母,数字每个字符占用1个字节
					中文每个字符占用3个字节

布尔类型:
	含义:
		用于声明真假值的数据类型
	特点:
		单独声明boolean类型变量,每个变量占用4字节内存
		声明boolean类型数组时,数组中的每个boolean元素占用1个字节内存

标识符

标识符:
	在程序中给变量,方法,类,接口,包等起的名字标识符的特点:
	
	硬性规则(必须遵守,如不遵守编译报错)
	软性规范(程序员间约定俗成)

硬性规则内容:
	1.标识符可以由26个大小写英文,0-9数字,美元符$,下划线_,中文组成
	2.0-9数字不能作为标识符的开始
	3.不能是程序中的53个关键字

软性规范:
	1.标识符不推荐使用中文;
	2.标识符命名的时候需要做到"见名知意"
	3.给不同的标识符命名的时候需要遵循不同的规范
		类的命名规范:
			一个单词:单词的首字母大写
			多个单词:每个单词的首字母大写
		方法的命名规范:
			一个单词:单词全部小写
			多个单词:第一个单词全部小写,第二个单词开始每个单词的首字母大写
		变量的命名规则:
			一个单词:单词全部小写
			多个单词:第一个单词全部小写,第二个单词开始每个单词的首字母大写

初始化值

初始化值:
	在程序中给变量赋的值。
	
	通用的特点和注意事项:
	1.给基本类型变量进行赋值的时候,初始化值必须在其数据类型的取值范围内
	2.现阶段,在给相同类型变量进行初始化赋值的时候,如果赋的值和某变量相同,可以将这个变量名赋值给该变量;
	3.在程序中,所有的变量在使用前都必须给其进行赋值

整数类型初始化值的注意事项:
	1.在给long类型进行初始化赋值时,需要在初始化值的后面添加字母l或L,推荐L
	2.给整数类型初始化赋值时,有四种初始化值写法,无论哪种写法,最后的结果都是十进制数字
		(1)十进制
		(2)二进制
			初始化值由0和1组成,并在前面加上0b或0B
		(3)八进制
			初始化值由0~7组成,并在前面加上0
		(4)十六进制
			初始化值10~15由a~f组成,并在前面加上0x或0X
浮点类型初始化值的注意事项
	1.浮点的初始化值由三部分组成:负数,整数,正数
	2.在给float类型进行初始化赋值时,需要在初始化值的后面添加字母F或f
布尔类型初始化值的注意事项
	布尔的初始化值只有两个:true和false
字符类型初始化值的注意事项:
	1.字符类型的初始化值由''进行表示,且''中字符的个数有且仅有一个
	2.给字符类型初始化赋值时,有四种初始化值写法,无论哪种写法,最后的结果都是''中的单个字符
		(1)''有且仅有单个字符
		(2)0~65535数字(对应Unicode码表上的字符)
			编码表:将十进制数字和对应的字符进行一一对应的编码表
			ASCII码表:世界上第一张编码表(美国),将0~127数字和26个英文大小写字母,数字,标点符号进行一一对应的码表
				0字符	十进制数字48
				A字符	十进制数字65
				a字符	十进制数字97
			Unicode码表:将0~65535数字和各国常用文字字符进行了一一对应
		(3)十六进制
			由'\占位uXXXX'组成,XXXX就是十六进制,不足四位,需要补0占位
		(4)转义字符
			'\字符'

		//十进制数字赋值
		int num01 = 10;
		System.out.println(num01);

		//二进制数字赋值
		int num02 = 0b10;
		System.out.println(num02);

		//八进制数字赋值
		int num03 = 010;
		System.out.println(num03);

		//十六进制数字
		int num04 = 0x10;
		System.out.println(num04);

		float num05 = 12.34F;
		System.out.println(num05);
		
		char c1 = 'a';
		System.out.println(c1);

		char c2 = 97;
		System.out.println(c2);

		char c3 = '\u0061';
		System.out.println(c3);

声明初始化8种基本类型变量和字符串变量并初始化

		//声明并初始化整数类型变量
		byte var1 = 123;
		System.out.println(var1);

		short var2 = 12345;
		System.out.println(var2);

		int var3 = 1234567890;
		System.out.println(var3);

		long var4 = 12345678900L;
		System.out.println(var4);

		//声明并初始化浮点类型变量
		float var5 = 12.34F;
		System.out.println(var5);

		double var6 = 67.89;
		System.out.println(var6);
		
		//声明并初始化字符类型变量
		char var7 = 'a';
		System.out.println(var7);

		//声明并初始化布尔类型变量
		boolean var8 = true;
		System.out.println(var8);

		//声明并初始化字符串类型变量
		String var9 = "HelloWorld";
		System.out.println(var9);

变量声明初始化的注意事项:

	1.在方法中声明的变量使用前必须给其进行初始化
	2.在同一作用域中不可以声明同名的变量
		作用域:变量所属的大括号
	3.变量的使用不能超出所属的作用域范围
	4.如果声明同一种数据类型多个变量,可以在一行上同时进行声明(在源码中)
		数据类型 变量名1 = 初始化值1 , 变量名2 = 初始化值2;

类型转换

类型转换:
	将符合要求的数据类型转换为另外的一种数据类型
分类: 
	基本类型与基本类型之间转换
	引用类型与引用类型之间转换
	基本类型与包装类型之间转换
	基本类型与字符串类型之间转换

基本类型间的转换

	关键:基本类型的取值范围
	分类:
		自动转换
		强制转换
	格式:
		数据类型 变量名 = (数据类型)待转换的数据;

自动转换(隐式转换)
	含义:
		将取值范围较小的数据类型转换为取值范围较大的数据类型
	注意:
		自动转换(隐式转换)也适用于类型转换的格式,但不推荐使用,即使我们不进行格式上的转换,JVM也会自动帮助我们完成转换
	基本类型取值范围从小到大的关系如下:
		byte < short < int < long < float < double
				char < int < long < float < double
				boolean类型不支持基本类型转换

思考题:在内存中float占4个字节,long占8个字节,为什么float的取值范围比long还大呢?
	1.基本类型的类型转换只和取值范围有关,和占用字节数无关
	2.long类型底层是十进制整数,float类型底层是IEEE754浮点计数标准(底层不是十进制整数,通过损失小数点后面的精度加大类型的取值范围)
	3.手动进行数学转换:
		long类型取值范围中最大的整数 < 2^63
		float类型取值范围中最大的整数 > 3.4*10^38 > 2*10^38 > 2*8^38 = 2*(2^3)^38 = 2*2^114 = 2^115

强制转换(显式转换)

	含义:
		将取值范围较大的数据类型转换为取值范围较小的数据类型
	注意:
		强制类型必须应用类型转换的格式
	格式:
		取值范围较小的数据类型 变量名 = (取值范围较小的数据类型)取值范围较大数据类型的数据值;

		//进行强制转换
		int num = (int)3.99;
		System.out.println(num);

注意事项

	基本类型间转换的注意事项：
	1.基本类型间转换是七种数值类型间的转换,boolean不可以进行基本类型间转换
	2.在实际的开发过程中尽量避免使用强制转换,可能发生数据精度的损失和溢出
	3.在程序中,byte,short,char这三种类型如果发生数学运算操作,先自动越级提升成int类型再参与运算操作;如果者三种类型没有发生数学运算操作,根据实际需要按照自动转换的方式进行提升

常量

	常量:在程序中其值不可以发生改变的量
分类:
	字面值常量
	自定义常量(暂不涉及,面向对象final讲解)

字面值常量:
	含义:
		单独的值,这样的值在程序中没有任何意义,必须借助其他语句才能进行使用
	分类:
		整数字面值
		小数字面值
		字符字面值
		布尔字面值
		字符串字面值
		空字面值
			null(暂不涉及,数组)
常量的注意事项:
		1.byte,short,char这三种数据类型在初始化赋值的时候,如果初始化值是整数字面值常量,且没有超出其数据类型的取值范围,JVM中的常量区自动在编译时期将初始化值优化为对应数据类型,我们将这一常量特性称之为"常量优化机制"
		2.给变量进行初始化赋值的时候,初始化值是一个计算式子,如果运算符号两边都是字面值常量,且运算后的结果还在其数据类型的取值范围内,JVM中的常量区自动在编译时期将该计算式子运算完毕,,我们将这一常量特性也称之为"常量优化机制"

两种常见的输出语句
	换行输出语句
		含义:
			先进行打印输出操作,再进行回车换行处理
		格式:
			System.out.println(输出内容);	
	直接输出语句
		含义:
			直接进行打印输出操作,不再进行其它处理
		格式:
			System.out.print(输出内容);	

注意事项:
	1.换行输出语句在没有任何输出内容时,直接进行回车换行处理
	2.直接输出语句在没有任何输出内容时,直接编译报错

运算符

运算符:在程序中用来连接变量或常量的运算符号
表达式:用运算符连接起来的式子
	举例:
		a + b
常见运算符:
	算术运算符
	赋值运算符
	关系运算符
	逻辑运算符
	三元运算符
	位运算符

算术运算符

算术运算符:
	含义:
		针对数据进行数学运算的运算符
	分类:
		计算运算符
			+ - * / %(取余,求余)
		自增运算符
			++
		自减运算符
			--
四则运算及取余运算

/和%的特点:
	/:计算两个数相除的商
	%:计算两个数相除的余数

		int a = 3;
		int b = 4;

		System.out.println(a + b);//7
		System.out.println(a - b);//-1
		System.out.println(a * b);//12
		System.out.println(a / b);//0 ,3 / 4 = 0 ...... 3
		System.out.println(a % b);//3

+号的多种用法

+号的多种用法
	1.加法运算符
	2.字符串连接符
		当+号两边有任何一边是字符串的时候,+不再起到加法运算的操作,转换为字符串连接符,将左右两边的内容牢牢的连接在一起
		
		String s1 = "Hello";
		String s2 = "World";
		System.out.println(s1 + s2);

字符串连接符的练习

		System.out.println("Hello" + 5 + 20);//==> Hello5 + 20 ==> Hello520
		System.out.println(5 + 20 + "Hello");//==> 25 + Hello ==>25Hello


		System.out.println('a' + 1);//char+int ==> 97+1==>98
		System.out.println("a" + 1);//String+int ==> a1
		System.out.println("" + 'a' + 1);//String+char+int==>String+int==>a1

自增自减运算符

自增自减运算符:++和--(以++为例)
	含义:
		++:自增运算符,一个运算符两个动作,将变量进行+1运算操作,将结果再赋值给该变量
		--:自减运算符,一个运算符两个动作,将变量进行-1运算操作,将结果再赋值给该变量
	格式:
		变量名++;
		++变量名;
	特点:
		单独使用:格式直接使用
			结论:进行单独使用的时候,前++和后++结果是一样的
		复合使用:格式结合语句进行使用
			结论:
				++在前,先自增,后使用
				++在后,先使用,后自增

		//单独使用
		int a = 3;
		//a++;
		++a;
		System.out.println("a = " + a);

		//复合使用
		int x = 3;
		//int y = ++x;
		int y = x++;
		System.out.println("x = " + x);
		System.out.println("y = " + y);

自增自减运算符的练习

		int a = 3;
		//int b = ++a + a++;
		//(a=4)4+4(a=5)=8(a=5)

		//int b = a++ + ++a;
		//3(a=4)+(a=5)5=8(a=5)

		//int b = a++ + a++;
		//3(a=4)+4(a=5)=7(a=5)

		int b = ++a + ++a;
		//(a=4)4+(a=5)5=9(a=5)

		System.out.println("a = " + a);
		System.out.println("b = " + b);
		int num = 3;
		num = num++;//++在后,先使用后自增,先将3的值赋值给num,再进行自增变为4,结果是4,实际中结果是3,为什么?先排除一个答案,结论没错?
		System.out.println("num = " + num);

获取指定数字的各个位上的数字

		//声明并初始化一个整数
		int num = 1234;
		//获取该整数各个位上的数字
		int ge = num % 10;
		int shi = num / 10 % 10;
		int bai = num / 100 % 10;
		int qian = num / 1000 % 10;
		//打印各个位上的数字
		System.out.println("个位上数字:" + ge);
		System.out.println("十位上数字:" + shi);
		System.out.println("百位上数字:" + bai);
		System.out.println("千位上数字:" + qian);

赋值运算符:

赋值运算符
	含义:进行赋值操作的运算符
	分类:
		标准赋值运算符
			=
		扩展赋值运算符
			+=,-=,*=,/=,%=,.......

扩展赋值运算符:
	格式:
		变量名 += 变量名或常量
	特点:
		将运算符两边的变量进行运算操作(运算操作取决于=外的符号),将结果再赋值给左边的变量
		举例:
			a += b 相当于 a = a + b;

		//标准赋值运算符
		int num = 3;//标准含义:将整数3赋值给int类型变量num

		//扩展赋值运算符
		int a = 3;
		int b = 4;
		a += b;
		System.out.println("a = " + a);//7
		System.out.println("b = " + b);//4

扩展赋值运算符的注意事项:
	1.扩展赋值运算符再进行运算操作完毕后,将结果赋值给左边的变量之前隐藏根据运算符左边的变量类型做了一步强制转换
	2.扩展赋值运算符进行运算符操作的时候,将左边的变量和右边的结果进行运算操作

		byte b1 = 3;
		byte b2 = 4;
		//b1 = b1 + b2;//报错:byte参与运算先提升成int再进行运算操作
		b1 += b2;
		int a = 3;
		int b = 4;
		a *= b + 5;//可能1:a*(b+5)=27   可能2:a*b+5=17
		System.out.println("a = " + a);

关系运算符

关系运算符:
	含义:判断两个数值之间关系的运算符
	分类:
		<,<=,>,>=,==,!=

==的含义:
	判断两个基本类型数值是否相等
!=的含义:
	判断两个基本类型数值是否不等

		int a = 3;
		int b = 4;
		int c = 4;

		System.out.println(a < b);//true
		System.out.println(a <= b);//true
		System.out.println(b < c);//false
		System.out.println(b <= c);//true

		System.out.println("===========================");

		System.out.println(a > b);//false
		System.out.println(a >= b);//false
		System.out.println(b > c);//false
		System.out.println(b >= c);//true

		System.out.println("===========================");

		System.out.println(a == b);
		System.out.println(b == c);

		System.out.println("===========================");

		System.out.println(a != b);
		System.out.println(b != c);

		System.out.println("===========================");

		System.out.println(a = b);

逻辑运算符

逻辑运算符:
	含义:
		用来多个判断条件的运算符
	分类:
		标准逻辑运算符
			& , | , ^ , !
		短路逻辑运算符
			&& , ||

标准逻辑运算符:
	运算符&:
		含义:
			与,且
		特点:
			有false则false
		应用:
			判断多个条件语句是否同时满足
	运算符|:
		含义:
			或
		特点:
			有true则true
		应用:
			判断多个条件语句是否至少满足一个
	运算符^:
		含义:
			异或
		特点:
			相同为false,不同为true
		应用:
			判断多个条件语句的结果是否不同
	运算符!:
		含义:
			非
		特点:
			非true则false,非false则true
		应用:
			针对判断条件的结果进行取反

		int a = 3;
		int b = 4;
		int c = 5;

		//&
		System.out.println(a > b & a > c);//false & false
		System.out.println(a > b & a < c);//false & true
		System.out.println(a < b & a > c);//true & false
		System.out.println(a < b & a < c);//true & true
		System.out.println("===================================");

		//|
		System.out.println(a > b | a > c);//false | false
		System.out.println(a > b | a < c);//false | true
		System.out.println(a < b | a > c);//true | false
		System.out.println(a < b | a < c);//true | true

		System.out.println("===================================");

		//^
		System.out.println(a > b ^ a > c);//false ^ false
		System.out.println(a > b ^ a < c);//false ^ true
		System.out.println(a < b ^ a > c);//true ^ false
		System.out.println(a < b ^ a < c);//true ^ true

		System.out.println("===================================");

		//!
		System.out.println(!true);
		System.out.println(!false);
		System.out.println(!!true);
		System.out.println(!!!true);

短路逻辑运算符
	&和&&区别:
		&和&&的结果是一样的.&&具有短路的效果,当&&前面的表达式结果为false时,后面的表达式不会被执行;无论&前面的表达式结果是什么,后面的表达式都会被执行;在实际应用中更推荐&&

	|和||区别:
		|和||的结果是一样的.||具有短路的效果,当||前面的表达式结果为true时,后面的表达式不会被执行;无论|前面的表达式结果是什么,后面的表达式都会被执行;在实际应用中更推荐 ||			

		int a = 3;
		int b = 4;
		int c = 5;

		//&
		System.out.println(a > b & a > c);//false & false
		System.out.println(a > b & a < c);//false & true
		System.out.println(a < b & a > c);//true & false
		System.out.println(a < b & a < c);//true & true
		System.out.println("===================================");

		//&&
		System.out.println(a > b && a > c);//false && false
		System.out.println(a > b && a < c);//false && true
		System.out.println(a < b && a > c);//true && false
		System.out.println(a < b && a < c);//true && true
		System.out.println("===================================");

		int x = 3;
		System.out.println(false & ++x == 3);
		System.out.println("x = " + x);

		System.out.println("==============");

		int y = 3;
		System.out.println(false && ++y == 3);
		System.out.println("y = " + y);		

三元运算符

三元运算符:
	含义:
		含有三个未知量的运算符
	格式:
		关系表达式 ? 结果值1 : 结果值2
	流程:
		1.先确认关系表达式的结果是true还是false;
		2.在确认关系表达式结果的同时,将结果值1和结果值2通过自动类型转换进行提升,统一两个结果值的数据类型
		3.如果是true,执行类型转换后的结果值1;
		  如果是false,执行类型转换后的结果值2;

		//打印两个整数中的较大值
		int a = 3;
		int b = 4;
		System.out.println(a > b ? a : b);
		System.out.println("===========================");

		//打印两个数(整数,小数)中的较大值
		System.out.println(true ? 3 : 4.5);

位运算符

位运算符:
	含义:
		针对二进制位进行操作的运算符
	分类:
		按位运算符
			&	|	^	~
		移位运算符
			<<	>>	>>>

按位运算符:
	运算符&:
		含义:
			按位与,当两位相同时为1时才返回1
	运算符|:
		含义:
			按位或,只要有一位为1即可返回1
	运算符^:
		含义:
			按位异或。当两位相同时返回0，不同时返回1
	运算符~:
		含义:
			按位非,将操作数的每个位（包括符号位）全部取反

移位运算符:
	运算符<<:
		含义:
			左移运算符
		格式:
			数据 << 位数
		特点:
			将二进制数据往左移动指定的位数,符号位也随之移动,低位出现空位需要进行补0进行操作
	运算符>>:
		含义:
			右移运算符
		格式:
			数据 >> 位数
		特点:
			将二进制数据往右移动指定的位数,符号位也随之移动,高位出现空位需要进行补和符号位相同的数据进行操作
	运算符>>>:
		含义:
			无符号右移运算符
		格式:
			数据 >>> 位数
		特点:
			将二进制数据往右移动指定的位数,符号位也随之移动,高位出现空位需要进行补0进行操作