JAVA基础笔记

一、基本篇 - 1
1、JAVA语言的特性
JAVA的底层是由C++实现的，开源、免费、纯面向对象、跨平台的
* 简单性
简单性是相对而言的，JAVA中不再支持多继承，并且JAVA中也屏蔽了指针的概念。
* 面向对象
JAVA是纯面向对象的，更符合人的思维模式，更容易理解。
* 可移植性
* 多线程
* 健壮性
自动垃圾回收机制，自动垃圾回收机制简称GC机制。
* 安全性

2、JAVA的3个版本
	* JAVASE(JAVA标准版)
	* JAVAEE(JAVA企业版)
	* JAVAME(JAVA微型版)
	
3、JDK、JRE、JVM的关系
	* JDK(JAVA Development Kit) - JAVA开发工具包
	* JRE(JAVA Runtime Environment) - JAVA运行环境
	* JVM(JAVA Virtual Machine) - JAVA虚拟机
	
	* 3者关系
		JDK 包含 JRE 和 JVM
		JRE 包含 JVM
		JDK 和 JRE 有单独的安装包，如果只是运行JAVA程序，不做开发，可以只安装JRE，不安装JDK

4、CLASSPATH 与 PATH环境变量的区别？
	* CLASSPATH 是给类加载器指路的，一般classpath 都配置成"."
	* PATH 是给JAVA工具指路的，以便在DOS命令行下，可以直接执行JAVA和JAVAC等命令

5、JAVA采用的是什么字符编码？
	* JAVA 语言源代码采用的是unicode字符编码，所以标识符也可以使用“中文”。

6、JAVA程序中提供了一套庞大的类库，java程序员是基于这套类库进行开发的。目录：
	* SE类库字节码：F:\jdk\jre\lib\rt.jar
	* SE类库源码：F:\jdk\src.zip

一、基本篇 - 2
1、java语言的注释？
* 单行注释 使用 “//”
* 多行注释 使用 “/* /"
* doc注释 使用 "/* */”

2、public class 与 class 的区别？
	* 一个java源文件中可以包含多个class，但是只能有一个public class（也可以没有public class）
	* 一个java源文件中的public class 的类名，必须和java源文件名称一致。
	* java源文件中如果存在多个class，则编译时，会生成多个class文件

3、一个完整的JAVA程序
	* 例如：
		public class HelloWorld{
			public static void main(String args[]){
			System.out.print("Hello World");			
			}
		}
	* 语句解释
	    public class HelloWorld  
			- 声明一个公共类，类名叫HelloWorld
		public static void main(String args[])
			- main方法，固定写法，其中void代表没有返回值。
			- String args[]为：传String类型的多个参数值
		System.out.print("Hello World");
			- 屏幕打印输出字符串：Hello World
			
4、名词解释
	* 标识符
		一般为类名或方法名称，例如：
		- “public class test”，其中test就是标识符
	* 关键字
		java语言使用的单词，例如：public、class、void、static 等等
	* 字面值
		一般为变量赋值时的值，例如：name = 'zhangsan'，其中'zhangsan'就是字面值
	* 变量
		内容可变的名称，例如name = '张三',sex = '男',其中name、sex就是变量

5、数据类型
	* 基本数据类型
		- byte
			字节大小 1，表示范围 [-128~127] -2^7 - 2^7 - 1，默认值是0
		- short
			字节大小 2，表示范围 [-32768~32767] -2^15 - 2^15 - 1，默认值是0
		- int
			字节大小 4，表示范围 -2^31 - 2^31 - 1，默认值是0
		- long
			字节大小 8，表示范围 -2^63 - 2^63 -1，默认值是0
		- float
			字节大小 4，单精度、32位，默认值是0.0
		- double
			字节大小 8，双精度、64位，默认值是0.0
		- boolean
			字节大小 1，只有两个取值：true 和 false，默认值是false【在C语言中，true代表1，false代表0】
		- char
			字节大小 2，char类型是一个单一的 16 位 Unicode 字符，默认值是\u0000
		
	* 八种基本数据类型的默认值一切向0看齐
	
	*char 和 String的区别？
		- char表示字符，定义时用单引号，只能存储一个字符，如char c=’x’; 
		  而String表示字符串，定义时用双引号，可以存储一个或多个字符，如String name=”tom”;

		- char是基本数据类型，而String 是一个类，具有面向对象的特征，可以调用方法，如name.length()获取字符串的长度。

6、数据类型详解
	* char类型
		- char 占用2个字节
		- 以下赋值是正确的
			char x = 'a';
			char x = '国'; //一个中文占用2个字节，char类型刚好是2个字节
		- 以下赋值是错误的
			char x = 'ab'; //'ab'是字符串类型，char是字符类型，类型不兼容
			char x = "a"; // "a"双引号表示字符串，类型不兼容
		- JDK的bin目录下有一个native2ascii可以将文字转换为unicode编码形式
			char n = '\u4e2d'      //'中'对应的unicode编码是4e2d
			char m = '中';
			System.out.println(n); //得到的结果是'中'，与System.out.println(m);的效果一样
		- char的默认值是\u0000
	
	* 整数型【byte、short、int、long】
	
		数据类型		占用空间大小		默认值		取值范围		
------------------------------------------------------------------------
		byte				1				  0			-128 - 127 (2^7-1 ~ 2^7-1)
		short				2 				  0			-32768 - 32767 (2^15-1 ~ 2^15-1)
		int					4				  0         -2147483648 - 2147483647 (2^31-1 ~ 2^31-1)
		long				8				  0L		-2^63-1 ~ 2^63 -1
	
		- JAVA中的整数型的字面值都当作int类型来处理，如果要让这个字面值被当作long类型来处理的话，要在“整数字面值”后面添加L
	
		- JAVA语言当中，整数型的字面值有三种表示方式：
			十进制 - 默认方式，常用
			八进制 - 以 0 开头，例如：int a = 010; //010是0 和 10，10是八进制中的8
			十六进制 - 以 0x 开头，例如：int b = 0x10; //0x10是0x和10，10是十六进制中的16
			字面值表达方式有三种，但是输出的时候统一使用的都是十进制。
	
		- 类型自动转换机制
			int b = 123; //不存在类型转换
			long a = 456; //由于java中的整数型字面值的默认类型是int，因此在赋值给long类型的a时，需要进行类型转换。
			byte c = 100; //这个可以直接进行赋值，在java中byte类型只要整数字面值不超出byte的取值范围，是可以直接赋值的（short和char（65535以内）也是）。
			TIPS:JAVA中小容量转换为大容量，可以直接进行转换，反之不可以。
		
			long x = 2147483647; //编译没问题
			long y = 2147483648; //编译时会报错（编译错误：过大的整数），因为在赋值前，2147483648被默认当作int类型来处理，但是数值超出了int的取值范围。
			long z = 2147483648L; //编译没问题，因为赋值前，2147483648L被当作long类型来处理，在long的范围内。
		
		- 类型强转
			JAVA默认小容量转大容量没问题，但是大容量转小容量可能会损失精度，需要谨慎使用。
			强制转换语法：
				int a = 100;
				byte b = (byte) a; //(int)就是强制类型转换，不加的话，编译会报错( 错误: 不兼容的类型: 从int转换到byte可能会有损失)，但是如果a大于100的时候，强制转换会损失精度。
			损失精度的原理：
				计算机中的编码是以补码的形式存在的。所以 a = 100中的100的二进制码值是：
				00000000 00000000 00000000 01100100
				转换为精度小的byte类型时，如果a大于127，则会出现精度损失，结果是负数。例如：
				当 int a = 500时，对应的二进制是：
				00000000 00000000 00000001 11110100
				转换为byte类型的时候，由于容量大转为容量小，会损失精度，结果就是只保留右边的一个字节：11110100
				并且，计算机中的存储是以补码的形式存在的，最终结果要转换为原码，所以强制转换为byte类型的最终结果就是：11110100 的补码（11110100的0和1取反（包括正负）再加1：00001100【-12】）
				
	* 浮点型【float、double】
		- float 单精度【4个字节】
		- double 双精度【8个字节，精度较高】
		- BigDecimal 这个精度更高，但是不属于基本数据类型，是引用数据类型，它是：java.math.BigDecimal
		
		- 在java语言中，所有的浮点型字面值，默认被当作double来处理。如果需要将该字面值使用float来处理，需要在结尾加上f/F;
		  例如： float a = 32.32f;
	
	* 布尔型【boolean】
		- 只有两个值：true 和 false;
		- 在底层存储的时候，boolean类型占用1个字节，true在底层存储时是1，false是0;

7、数据类型转换
	* 八种基本数据类型，除了boolean类型之外，其它7种类型可以互相转换，转换规则如下：
		- 小容量可以向大容量自动进行转换，容量从小到大排序：
			byte < short/char < int < long < float < double
			注：任何浮点类型不管占用多少个字节，都比整数型容量大。
				char 和 short 可以表示的种类数量相同，但是char可以取更大的正整数。
		- 大容量可以转为小容量，但是需要进行强制类型转换，可能会损失精度。
		- 当整数字面值没有超出byte、short、char的取值范围，可以直接进行赋值给byte、short、char。
		- byte、short、char进行混合类型运算的时候，各自先转换为int类型，再进行运算。
		- 多种数据类型混合运算，先转换成容量最大的那个数据类型，再进行运算。

8、运算符
	* 算术运算符
		- +		求和
		- -		相减
		- *		相乘
		- / 	商
		- %		余数
		- ++	自加一 //int x = 1;x++和++x效果一样，都是加一
		- --	自减一 //int x = 1;x--和--x效果一样，都是减一
		- int a = 0; b = a++; //结果b还是0，先做赋值运算，再做++运算
		- int a = 0; b = ++a; //结果b是1，先做++运算，再做赋值运算
		
	* 关系运算符
		- >		大于
		- <		小于
		- ==	等于
		- >=	大于等于
		- <=	小于等于
		- !=	不等于
		- 关系运算符的结果一定是布尔类型的结果 true/false
	* 逻辑运算符
		- &		逻辑与（两边的算子都是true，结果就是true）
		- |		逻辑或（两边的算子只要有一个是true，结果就是true）
		- ！	逻辑非（结果取反，true就是false，false就是true）
		- ^		逻辑异或（两边的算子只要不一样，结果就是true）
		
		- &&	短路与（与逻辑与的最终运算结果是一致的，只不过存在短路现象）
		- ||	短路或（与逻辑或的最终运算结果是一致的，只不过存在短路现象）
		- 逻辑运算符要求两边的算子都是布尔类型，并且运算的最终结果也是一个布尔类型。
		
		- 逻辑与 和 短路与的区别？
			例：
				int a = 8;
				int b = 10;
				( a > b & a < 9)  //即使 a > b 返回的是false，后面的a>9也会执行，根据特殊的业务要求，会执行此种运算方式。
				( a > b && a < 9) //如果 a > b 返回的是false，后面的就不会执行了。
		
		- 同短路与，短路或只要一个表达式是true，就会直接返回true，后面的表达式直接不执行。根据业务场景，可以选择逻辑或。
		
	* 赋值运算符
		- 基本赋值运算符： =
			int a = 10; //“=”起赋值作用
		- 拓展的赋值运算符：
			+= // a+=10;也可以写成：a = a + 10;
			-= // a-=10;也可以写成：a = a - 10;
			*= // a*=10;也可以写成：a = a * 10;
			/= // a/=10;也可以写成：a = a / 10;
			%= // a%=10;也可以写成：a = a % 10;				
			运算优先级：都是先执行等号右边的内容，再赋值给左边的变量。
			***注意***
				a+=10 也并不完全等同于 a = a + 10，例如：
				byte a = 10;
				a = a + 5;	//编译会报错，因为整数型的默认类型是int，所以右边的结果也是int类型的，所以再赋值给左边的byte类型会报错。
				a += 5;	//这个编译不会报错。
				所以，上面的话可以纠正成为：a += 5; 等同于a = (byte) (a + 5);
				但是，写成a += 5;的格式的时候，如果超出了数据类型的范围，程序也可以编译通过，但是会损失精度。
		
	* 字符串连接运算符
		- 连接运算符是: +
			当“+”两边都是数字的话，“+”会进行求和运算
			数字 + 数字 --> 数字【求和运算】
			当“+”两边只要有一个是字符串类型的话，“+”会进行字符串连接运算，连接之后的结果还是一个字符串类型。
			数字 + “字符串” --> “字符串”【字符串连接运算】
			
			当一个表达式中同时出现多个“+”，运算顺序从左往右依次执行。例：
			System.out.println(10 + 20 + 30);//第一个“+”和第二个“+”都是进行的求和运算，最终结果是60
			System.out.println(10 + 20 + "30");//第一个“+”进行的是求和运算，第二个“+”都是进行的是字符串连接运算，最终结果是3030
			System.out.println(10 + (20 + "30"));//按照括号的优先级进行运算，最终结果是102030

	* 三元运算符/三目运算符/条件运算符
		- 语法规则：
			布尔运算符 ? 表达式1 : 表达式2
			例如：
				boolean sex = false;
				char s = sex ? '男' : '女';
		- 如果前面的布尔运算符的结果是true，则整个表达式的结果是表达式1的运算结果，反之是表达式2的运算结果。
	

9、成员变量没有手动赋值，系统会赋默认值。局部变量不赋值会报错。
		
10、JAVA中反斜杠“\”代表转义符号
	* 常用的转义后的符号如下：
		\n	换行
		\t	制表符tab
		\\	反斜杠
		\u	unicode转义

11、从键盘读取输入内容
	* 例：
		public class ReadFromKeyboard{
			public static void main(String args[]){
				java.util.Scanner s = new java.util.Scanner(System.in);
				String str = s.next();//读取字符串信息
				//int num = s.nextInt();  //读取数字信息
			}
		
		}

三、基本篇 - 3
1、控制语句
* 选择结构
- if/if…else
基本语法：
if(布尔表达式){
JAVA语句;
}else if(布尔表达式){
JAVA语句;
}else if(布尔表达式){
JAVA语句;
}else{
JAVA语句;
}
其中，if是必须的，else if 和 else 可以没有。
所有的控制语句是可以相互嵌套的，只要合理使用即可。
if语句的分支中只有一条java语句的话，大括号可以省略不写，例如：
if(布尔表达式){
一条JAVA语句;
}
也可以写成：
if(布尔表达式) 一条JAVA语句;//不建议使用，格式不好看

		- switch
			switch语句也属于选择结构，也是分支语句。
			switch语句的语法结构：
				switch(int或String类型的字面值或者变量){
					case int或String类型的字面值或者变量:
						java语句;
						...
						break;
					case int或String类型的字面值或者变量:
						java语句;
						...
						break;
					...
					default :
						java语句;
						...
						break;
				
				}
			
			switch语句的执行规则：
				switch小括号里面的“字面值或变量”与大括号中的case后面的“字面值或变量”进行一一匹配，匹配成功的分支执行。						
					如果匹配分支执行的java语句中有break，则整个switch结束。
					如果没有break结束，则后续分支不再进行匹配，直接执行java语句，直到语句结束或者碰到下一个break，这种现象叫做case穿透现象;
				如果所有的分支都没有匹配成功，则会执行default分支
				判断内容的类型只能是int或者String类型，byte、short、char也可以使用，但是会自动进行类型转换。
				case可以合并，例如：
					int a = 10;
					switch(a){
						case 1: case 2: case 3: case 4:
							System.out.println("1234");
							break;
						case 5: case 6: case 7:
							System.out.println("567");
							break;
						case 8: case 9: case 10:
							System.out.println("8,9,10");
							break;
						default :
							System.out.println("0");						
					}
		
	* 循环结构
		- 循环结构是将一段需要重复执行的代码，放到循环体中，联合计数器控制代码的执行次数，完成需求。
		- for
			-> 语法规则：
					for(初始化表达式;布尔表达式;更新表达式){
						java语句;   //循环体
					}
					--> 初始化表达式、布尔表达式、更新表达式都不是必须的,但是2个分号是必须的。
					--> 初始化表达式最先执行，并且在整个for循环中仅执行一次。
					--> 布尔表达式的结果必须是true或者false，不能是其他值。
					--> for的执行过程:
						---> 先执行初始化表达式
						---> 执行布尔表达式
								结果是true：
									执行循环体
									执行更新表达式
										执行布尔表达式
											结果是true：
												执行循环体
												执行更新表达式
													执行布尔表达式
													...
											结果是false：
												for循环结束
								结果是false：
									for循环结束
			-> 例子：
					//打印1-100
					for(i=1;i<=100;i++){
						System.out.println(i); //i的作用域仅限于当前的for循环内部
					}
		- while
			-> 语法规则：
				while(布尔表达式){
					java语句;  //循环体
				}
			-> 执行原理：
				--> 先执行布尔表达式
					--> 结果为true
						---> 执行循环体
						---> 执行布尔表达式
							----> 结果为true
								-----> 执行循环体
								-----> 执行布尔表达式
								...
							----> 结果为false
								-----> while循环结束
						
					--> 结果为false
						---> while循环结束
		- do..while
			-> 语法规则：
				do{
					java语句;  //循环体
				}while(布尔表达式);
			
			-> 执行原理：
				--> 先执行循环体，然后再执行布尔表达式
					---> 布尔表达式的结果为true
						----> 执行循环体
						----> 执行布尔表达式
							-----> 布尔表达式为true
								....
					--->
						----> 循环结束
			-> 注意事项：
				--> do...while 循环至少会执行一次
				--> do...while 循环最后有一个分号“;”
	* 控制循环语句
		- continue
			-> "continue;" 是一个完整的java语句
			-> continue 表示当前循环体中，continue语句后面的java语句不再执行，直接进入下一次循环。
			-> continue 也有这样的语法：
				continue 循环名称;  //直接进入另一个循环
		- break
			-> "break;" 是一个完整的java语句
			-> break 可以用在switch语句中，用来终止switch语句的执行。
			-> break 也可以用在for循环、while循环、do...while循环中，终止循环的继续执行。
			-> break 语句只能终止离他最近的一个循环，即break所在的循环体。

二、进阶篇 - 1
1、方法（函数）
* 方法的基础语法
[修饰符列表] 返回值类型 方法名(形式参数列表){
方法体;
}
例如：
public static void sumResult(int a;int b;){
System.out.println(a+b);
}

		- 修饰符列表
			-> 可选项，不是必须的
			-> 方法的修饰符中有static的话，调用方法的方式为：
				类名.方法名(实际参数列表);
				没有static的变量被称为“实例变量”，没有static的方法被称为“实例方法”，调用的时候必须要有对象参与
				带有static的方法，在访问的时候，直接访问和使用对象访问，两种方式没有区别。
				
		
		- 返回值类型
			-> 什么是返回值?
				--> 返回值是方法执行后，返回给调用方的一个值，返回值类型不是void，方法就一定要有返回值，否则编译报错。
			-> 返回值类型可以是java中的任意一种类型，可以是基础数据类型，也可以是引用数据类型，方法的最终返回值必须和定义的返回值类型一致。
			-> 方法的返回值不是必须的，如果返回值类型是void，方法不需要有返回值。
			-> 返回值使用“return 数据类型”进行返回。执行return后，方法结束。
			-> 返回值类型为void的时候，方法中可以使用return，但是不能使用“return 返回值”，会编译报错【对结果为空的方法，无法返回值】。
		
		- 方法名
			-> 方法名没有强制性要求，符合标识符命名规范即可。
			-> 方法名一般首字母小写，后面没有单词首字母大写，遵循驼峰命名法。
		
		- 形式参数列表【简称形参】
			-> 形参是局部变量:int a;double b;float c;String s;...
			-> 形参没有个数限制
			-> 多个形参使用逗号分隔
			-> 形参起决定性作用的就是形参的数据类型，形参的名字就是局部变量的名字。
			-> 方法在被调用的时候，实际给这个方法传递的真实数据叫做实际参数，简称实参。
			-> 例如：
				public static int getSum(int a;int b){
					return a + b;
				}
				类.getSum(10,20);
				--> 其中，a 和 b 叫做形参。方法被调用时，10和20就是对应的实参。
			-> 实参和形参必须数量一致，类型也一致。
		
		- 方法体
			-> 方法体需要使用大括号括起来。
			-> 方法体中的代码执行顺序是自上而下
					
		- 方法就是一段代码片段，并且这段代码片段可以完成某个特定的功能，并且可以被重复使用。
		 
		- 方法定义在类体当中，一个类体可以包含多个方法，且方法编写的位置没有先后顺序。
		 
		- 方法中不能嵌套定义方法，但是可以调用别的方法。
		 
		- 方法的调用
			-> 方法只有在调用的时候才会执行
			-> 方法的修饰符中有static的话，调用方法的方式为：
				类名.方法名(实际参数列表);
				如果类调用的方法为当前类中的方法，类名可以省略不写。
	
	* main方法与普通方法的区别？
		- 一个类中可以有多个方法，但是只能有一个main方法
		- main方法是程序的唯一入口，是肯定会执行的
		- main方法最先被调用，也是最后一个结束。
		- main方法有固定的写法：
			//(String[] args),String[]是一种引用数据类型，args是一个局部变量的变量名。
			public static void main(String[] args){
					
			}
		- 普通方法可以有多个，只有在被调用的时候才会执行。
	
	* 方法在被调用的时候，内存是怎么分配的？
		- 方法只定义，不调用，是不会执行的，并且在JVM中也不会给该方法分配“运行所属”的内存空间。
		  只有在被调用的时候，才会动态的给这个方法分配所属的内存空间。
		 
		- 在JVM内存划分上，有三块主要的内存空间（除了这三块之外，还有其它的内存空间）：
			-> 方法区内存
			-> 栈内存
			-> 堆内存
		
		- 关于“栈”的数据结构：
			-> 栈：stack，是一种数据结构
			-> 数据结构反应的是数据的存储形态
			-> 数据结构是独立的学科，不属于任何语言的范畴，只不过在大多数编程语言当中要使用数据结构。
			-> 作为程序员需要提前精通：数据结构 + 算法【计算机专业必修的一门课程】
			-> java程序员也可以不精通数据结构和算法，因为可以使用java内置的庞大的类库
			-> 常见的数据结构：
				--> 数组
				--> 队列
				--> 栈
				--> 链表
				--> 二叉树
				--> 哈希表/散列表
				...
		
		- 方法被调用的时候，片段存在哪里？方法在执行的时候，执行的内存在哪里分配？
			-> 方法代码片段属于.class字节码文件的一部分，字节码文件在类加载的时候，将其放到了方法区中。
			   所以JVM中三块主要的内存空间中，方法区内存中最先有数据。存放了代码片段。
			-> 代码片段虽然在方法区中只有一份，但是可以被重复调用。每一次调用这个方法的时候，需要给该方法
			   分配独立的活动场所，在栈内存中分配。【栈内存中分配方法运行所属的内存空间】
		
		- 方法在被调用的瞬间，会给该方法分配内存空间，会在栈中发生压栈（入栈/put）动作，方法在执行结束后，会将分配给该方法使用的内存全部释放，
		  此时发生弹栈（出栈/pop）动作。
			-> 压栈：给方法分配内存
			-> 弹栈：释放该方法的内存空间
		
		-> 局部变量在“方法体”中声明。局部变量运行阶段内存在栈中分配。
	
	* 方法的重载机制overload
		- 定义
			方法重载是指在一个类中定义多个同名的方法，但要求每个方法具有不同的参数的类型或参数的个数。
			调用重载方法时，Java编译器能通过检查调用的方法的参数类型和个数选择一个恰当的方法。
			方法重载通常用于创建完成一组任务相似但参数的类型或参数的个数或参数的顺序不同的方法。
			Java的方法重载，就是在类中可以创建多个方法，它们可以有相同的名字，但必须具有不同的参数，即或者是参数的个数不同，或者是参数的类型不同。
			调用方法时通过传递给它们的不同个数和类型的参数，以及传入参数的顺序来决定具体使用哪个方法
		
		- 什么时候考虑使用方法重载？
			--> 功能相似的时候，尽可能让方法名相同
		
		- 什么条件满足后构成方法重载？
			-> 在同一个类当中
			-> 方法名相同
			-> 参数列表不同：
				--> 数量不同
				--> 顺序不同
				--> 类型不同
				
		- 方法重载和什么有关系？和什么没有关系？
			-> 方法重载和方法名+参数列表有关系
			-> 方法重载和返回值类型无关
			-> 方法重载和修饰符列表无关
		
	* 方法的递归调用
		- 什么是方法递归？
			-> 方法自身调用自身
				void a(){
					a();
				}
			-> 递归是很费栈内存的，递归算法可以不用的时候尽量不使用
			
			-> 递归必须要有结束条件，没有结束条件，递归就会无限执行下去，最终导致栈内存溢出，JVM停止工作
			
			-> 递归即使有了结束条件，即使结束条件是正确的，也有可能发生栈内存溢出错误，因为递归的太深了。
	
	* 方法的覆盖
		- 方法覆盖被称为方法重写，override/overwrite
		- 当父类中的方法不能满足当前子类方法的需求，需要将从父类继承的方法进行重写，这种重新编写的过程叫做方法覆盖/方法重写
		- 什么条件下构成方法覆盖？
			-> 方法覆盖发生在具有继承关系的父子类之间
			-> 子类的方法和父类的返回值类型、方法名称及参数类型都一致。
			-> 访问权限不能更低，可以更高
			-> 抛出异常不能更多，可以更少
		- 注意：
			-> 私有方法不能继承，所以不能覆盖
			-> 构造方法不能继承，所以不能覆盖
			-> 静态方法不存在覆盖。
			-> 覆盖只针对方法，不针对属性。

三、核心篇
1、面向对象
* 面向对象和面向过程的区别？
- 面向过程：
–> 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低
–> 缺点：很难解决比较复杂的业务逻辑、软件元素之前的“耦合度”非常高，只要其中一环出问题，整个系统受到影响、没有独立体的概念，组件无法复用。

		- 面向对象：
			--> 优点：耦合度低，拓展力强。更容易解决现实世界中更复杂的业务逻辑。组件复用性强。更符合人的思维方式
			--> 缺点：
		
		- C语言是纯面向过程的，C++是半面向对象的、java是纯面向对象的
		
		- 现在新出的编程语言，大部分都是面向对象的
	
	* 面向对象的三大特征？
		- 封装
			-> 什么是封装？
				-> 封装，即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。
			-> 封装的意义？
				-> 将更多的细节和属性隐藏，对外提供一个简单、安全的实现方式。
				
		- 继承
			-> 继承的基本作用是：代码复用，但是继承更重要的作用是：有了继承以后才有的方法覆盖和多态机制。
			-> 继承的语法格式：
				[修饰符列表] class 类名 extends 父类{
					类体;
				}
			-> java语言当中只支持单继承，一个类只能继承一个类。
			-> 继承的术语：
				B类继承A类：
					B类可以称为：子类、派生类、subclass
					A类可以称为：父类、基类、超类、superclass
			-> 可以继承哪些数据？
				--> 私有的不能继承
				--> 构造方法不支持继承
				--> 其他的都可以继承
			-> 类之间可以间接继承：
				A类继承B类，B类继承C类，那么A类就是间接继承了C类
				如果一个类没有显式的继承某个类，那么默认继承java.lang.Object类
				
		- 多态
			-> 关于多态的几个概念：
				--> 向上转型（upcasting）
					---> 子类型转换为父类型
					---> 自动类型转换
				--> 向下转型（downcasting）
					---> 父类型转换成子类型
					---> 强制类型转换（需要加强制类型转换符）
				--> 无论是向上转型还是向下转型，两种类型一定要有继承关系
			-> JAVA中允许这种语法：父类型的引用指向子类型对象，例如：
				Animal a = new cat();
				但是程序在运行阶段，JVM中真实创建的对象是cat对象，所以程序在调用运行的时候，会先执行cat的方法。
			
			-> 父类型引用指向子类型对象，这种机制导致程序在编译阶段绑定和运行阶段绑定两种不同的形态/状态，这种机制可以称为一种多态语法机制。
			
			-> instanceof运算符
				语法：
					（引用 instanceof 数据类型名）
				运算结果是布尔类型：
					true / false
				例如：
					(a instanceof Animal)
					true表示:
						a这个引用指向的是一个Animal类型
					false表示：
						a这个引用指向的不是一个Animal类型
					
					if(a3 instanceof Cat){
						Cat c3 = (Cat)a3;
						a3.catchMouse();
					}else if(a3 instanceof Bird){
						Bird c3 = (Bird)a3;
						c3.fly();
					}
			-> 多态的作用：
				降低程序耦合度，提高程序的拓展力
				能使用多态尽量使用多态
				父类型引用指向子类型引用
				
				
				
					
				
		
	* 采用面向对象的方式开发一个软件，生命周期当中主要分为三大部分：
		- 面向对象的分析：OOA(object-oriented analyze)
		- 面向对象的设计：OOD(object-oriented design)
		- 面向对象的编程：OOP(object-oriented programme)
	
	
	* 对象的创建和使用
		- 创建对象也可以称为对象的实例化
		- 一个类可以创建多个实例对象
		- 实例对象的方法：new 类名();
		- 堆内存，存放对象；

2、内存分析
	* JVM(java虚拟机)主要包括三块内存空间，分别是：堆内存、栈内存、方法区内存
	* 堆内存和方法区内存只有一个，一个线程一个栈内存
	* 方法调用的时候，该方法所需要的内存空间在栈内存中分配，成为压栈。方法执行完毕，该方法所属的内存空间释放，称为弹栈。
	* 栈中主要存储的是方法体中的局部变量
	* 方法的代码片段以及整个类的代码都被存储到方法区中执行，当类加载的时候，这些方法会被载入。
	* 在程序执行过程中使用new运算符创建的java对象，存储在堆内存当中。对象内部有实例变量，所以实例变量存储在堆内存当中。
	* 变量分类：
		- 局部变量：方法体中声明
		- 成员变量：方法体外声明
			-> 实例变量【前面修饰符没有static】
			-> 静态变量【前面修饰符有static】
	* 静态方法存储在方法区内存当中。
	* 三块内存当中变化最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收器主要针对的是堆内存。
	* 垃圾回收器【自动垃圾回收机制、GC机制】什么时候会考虑将某个java对象的内存回收呢？
		- 当堆内存当中的java对象成为垃圾数据的时候，会被垃圾回收器回收，
		- 什么时候堆内存当中的java对象会变成垃圾呢？
			-> 没有更多的引用指向它的时候。
			-> 这个对象无法被访问，因为访问对象只能通过引用的方式访问。

3、空指针异常
	* 空引用（null）访问实例相关的数据会出现空指针异常。
		
4、构造方法
	* 构造方法又被称为构造函数/构造器/Constructor
	* 构造方法的语法结构：
		【修饰符列表】 构造方法名(形式参数列表){
			构造方法体;
		}
	* 对于构造方法来说，“返回值类型”不需要指定，并且也不能写void，只要写上void，这个方法就成为普通方法了。
	* 构造方法的名称必须和类名一致。
	* 构造方法的作用：
		- 通过构造方法的调用，可以创建对象
		- 创建对象的同时，初始化实例变量的内存空间
		- 创建对象的时候，构造方法就会执行
	
	* 构造方法怎么调用？
		- 普通方法：类名.方法名(实参列表)
		- 构造方法：new 构造方法名(实参列表)
	
	* 构造方法有返回值吗？
		- 有返回值，但是return不需要写。
		- 并且返回值类型是构造方法所在类的类型。
		- 由于构造方法返回值的类型就是类本身，所以return不需要写。
	* 当类中没有编写构造方法的时候，系统会默认给类提供一个没有返回值的构造方法，这种构造方法又被称为缺省构造器。
	* 当类中的构造方法显式的定义出来了，系统不再为这个类提供缺省构造器。
	* 构造方法可以重载。

5、参数传递
	- java中涉及到的参数传递的问题，实际上传递的是变量的值，只不过这个值有时候是一个字面值，有时候是一个对象的内存地址。

6、this关键字
	- this是一个引用，是一个变量，this变量中保存了内存地址指向了自身，this存储在JVM堆内存java对象内部。
	- 创建100个JAVA对象，每个对象都有this，也就是说有100个不同的this。
	- 多数情况下，this可以省略（如：在实例方法中调用另一个实例方法，可以省略this）
	- this不能使用在带有static的方法中
	- 构造方法中可以使用this(实参) 调用另一个构造方法，但是this(实参)必须要出现在构造方法中的第一行

7、static关键字
	- 静态变量在类初始化的时候就已经初始化了，不需要创建对象，内存就开辟了。
	- 每个对象都有这个属性，并且这个属性的值对于所有对象来说，都是一样的，就可以建成静态变量，可以节省内存开销。
	- 可以使用static关键字来定义静态代码块：
		-> 语法格式：			
			static {
				java语句;
			}
		-> 静态代码块在类加载时执行，并且只执行一次
		-> 静态代码块，在一个类中可以编写多个，自上而下依次执行
		-> 通常在静态代码块中完成预备工作，先完成数据准备，例如：初始化连接池，解析xml配置文件
		-> 与之相对的还有实例代码块，在初始化对象的时候执行，在构造方法前执行。
		-> 方法描述的是动作，当所有的对象执行这个动作的时候，产生的影响是一样的时候，这个方法就可以定义为静态方法。

8、final关键字
	- final修饰的类，无法被继承
	- final修饰的方法，无法被覆盖
	- final修饰的变量，不可重新赋值
	- 实例变量使用final，必须手动赋值
	- final修饰的引用，一旦指向某个对象之后，不能再指向其他对象
	- final和static一起使用，可以定义一个常量名
		public static final 类型 常量名 = 值;
		java规范中要求所有的常量名都使用大写，单词之间使用下划线连接

9、包机制
	- 包又称为package，java中引用包机制是为了方便程序的管理。不同功能的类放到不同的包中，比较容易查找和管理及维护。
	- 如何定义package？
		语法：
			package 包名
		在java源程序的第一行写package语句，只能写一个语句。
	- 命名规范：
		- 公司域名倒序 + 项目名 + 模块名 + 功能名
		采用这种方式重名的概率较低，因为公司域名具有全球唯一性，例如：
			com.helloword.javase.test01
	- 包名要求全部小写，包名也是标识符，也需要遵守标识符的命名规范。
	- 一个包对应的是一目录
	- 使用package后如何编译？如何执行？
		javac -d 编译后目录 java源文件
		javac -d . test01.java
		java com.helloword.javase.test01
	
	- 在同一个包里面，引用class对象的时候，可以省去包名
	- 不在同一个包里面，使用的时候需要加上import class文件名
	- java.lang 下面的所有class不需要手动导入

10、权限访问限制符
	- private	只有当前类可以访问
	- 缺省		只有同包可以访问
	- protected	同包、子类 可以访问
	- public 	表示公开的，在任何位置都可以访问
	private < 缺省 < protected < public
	
	类只能使用public和缺省的修饰符进行修饰【内部类除外】

四、工具篇
1、Eclipse
* 常用快捷键：
- ctrl + d 删除一行
- alt + / 自动补全
- ctrl + 放大字体
- Ctrl + 1 自动纠错
- ctrl + / 注释和取消注释，多行注释 ctrl + shift + /
- ctrl + o 可以快速查看当前类中的所有元素
- ctrl + shift + r 查找资源
- ctrl + shift + t 查找类型
- ctrl + shift + o 快速导入类（包）