2021-05-05

JAVASE总结

1 环境搭建(软件安装,开发软件安装和使用)
见笔记教程
2 程序基础

1、数据类型

1.1、数据类型有什么用？
	数据类型用来声明变量，程序在运行过程中根据不同的数据类型分配不同大小的空间。
	int i = 10;
	double d = 1.23;
	i变量和d变量类型不同，空间大小不同。

1.2、数据类型在java语言中包括两种：

	第一种：基本数据类型
		基本数据类型又可以划分为4大类8小种：
			第一类：整数型
				byte,short,int,long （没有小数的）
			第二类：浮点型 
				float,double （带有小数的）
			第三类：布尔型
				boolean：只有两个值true和false，true表示真，false表示假
			第四类：字符型
				char：java中规定字符型字面量必须使用单引号括起来。属于文字。

		8小种：
			byte,short,int,long
			float,double
			boolean
			char

	第二种：引用数据类型
		字符串型String属于引用数据类型。
		String字符串不属于基本数据类型范畴。
		java中除了基本数据类型之外，剩下的都是引用数据类型。
		引用数据类型后期面向对象的时候才会接触。

1.3、8种基本数据类型中
	整数型：byte short int long有什么区别？
	浮点型：float和double有什么区别？
	区别：占用的空间大小不同。
		类型			占用字节数量(byte)
		------------------------------------
		byte				1
		short				2
		int				4
		long				8
		float				4
		double			8
		boolean			1  (1byte的1或0，00000001(true)或00000000(false))
		char				2

1.4、byte类型的取值范围?		
	byte是 [-128 ~ 127] 共可以标识256个不同的数字。
	byte类型的最大值是怎么计算出来的？
		byte是1个字节，是8个比特位，所以byte可以存储的最大值是：
			01111111

1.5、在类型转换的时候需要遵循哪些规则？

		第一条：八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以
		进行转换；
	
		第二条：如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋
		值给byte,short,char 类型的变量；
	
		第三条：小容量向大容量转换称为自动类型转换，容量从小到大的排序为：
		byte < short(char) < int < long < float < double，其中 short和 char 
		都占用两个字节，但是char 可以表示更大的正整数；
	
		第四条：大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，
		但运行时可能出现精度损失，谨慎使用；
	
		第五条：byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；
	
		第六条：多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；

2. 操作符 : +±-, & , && , ! , += , +

算术运算符：
	+ - * / % ++ --

关系运算符：
	> >= < <= == != 

逻辑运算符：
	& | ! && ||

赋值运算符：
	= += -= *= /= %=

三目运算符：
	布尔表达式 ? 表达式1 : 表达式2

字符串连接运算符：
	+

3.流程控制 : 顺序结构,分支结构,循环结构

控制语句
1.1、控制语句的出现可以让我们的程序具有逻辑性/条理性，可以使用控制语句
来实现一个“业务”了。

1.2、控制语句包括几类？
	3类：
		选择语句
		循环语句
		转向语句

1.3、选择语句也可以叫做分支语句
	if语句
	switch语句

1.4、循环语句：主要循环反复的去执行某段特定的代码块
	for循环
	while循环
	do..while..循环

1.5、转向语句
	break
	continue
	return（这个目前先不需要学习，后面讲方法的时候会使用。）

控制语句

2.1、关于循环语句
	for循环
	while循环
	do..while循环

	什么是循环语句，为什么要使用这种语句？
		因为在现实世界当中，有很多事情都是需要反复/重复的去做。
		对应到程序当中，如果有一块代码需要重复执行，此时为了减少
		代码量，我们使用循环语句。

2.2、关于转向语句：
	break;
	continue;
	return;

	选择语句
		if
		switch
	循环语句
		for
		while
		do..while
	转向语句
		break;
		continue;
		return;
	
	1、选择语句/分支语句 if
		四种写法。
		语法机制：
			if(布尔表达式){
			}
			
			if(布尔表达式){
			}else{
			}

			if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}

			if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else if(布尔表达式){
			}else{
			}

			if语句嵌套：
				if(布尔表达式){ //前提条件
					if(布尔表达式){
						if(布尔表达式){
						
						}else{
						
						}
					}
				}else{
				
				}
			
		执行原理：
			对于一个if语句来说，只要有1个分支执行，整个if语句结束。
			当布尔表达式的结果为true时，分支才会执行。
			分支当中只有一条java语句，大括号可以省略。
			带有else的可以保证肯定会有一个分支执行。

	3、选择语句/分支语句 switch

		完整语法结构：
			switch(值){ //值允许是String、int，（byte,short,char可以自动转换int）
			case 值1: case 值x:
				java语句;
				break;
			case 值2:
				java语句;
				break;
			case 值3:
				java语句;
				break;
			default:
				java语句;
			}

	4、for循环

		for循环语法机制：
			for(初始化表达式;条件表达式;更新表达式){
				循环体;
			}

			for(int i = 0; i < 10; i++){
				System.out.println(i);
			}

		for循环执行原理：
			1、先执行初始化表达式，并且只执行1次。
			2、然后判断条件表达式
			3、如果为true，则执行循环体。
			4、循环体结束之后，执行更新表达式。
			5、继续判断条件，如果条件还是true，继续循环。
			6、直到条件为false，循环结束。

	5、while循环
		while(布尔表达式){
			循环体;
		}
		执行次数：0~N次。

	6、do..while循环
		do{
			循环体;
		}while(布尔表达式);

		执行次数：1~N次。

	7、break;
		默认情况下，终止离它最近的循环。
		当然，也可以通过标识符的方式，终止指定的循环。

		for(int i = 0; i < 10; i++){
			if(i == 5){
				break;
			}
			code1;
			code2;
			code3;
			code4;
			....
		}

	8、continue;
		终止当前“本次”循环，直接跳入下一次循环继续执行。
		for(int i = 0; i < 10; i++){
			if(i == 5){
				continue;
			}
			code1;
			code2;
			code3;
			code4;
			....
		}

4 方法 : 目的,声明,调用,分类,重载,递归

	1、方法是什么？
方法是一段可以完成某个特定功能的并且可以被重复利用的代码片段。
方法的出现，让代码具有了很强的复用性。

2、方法最难实现的是：
根据业务怎么进行方法的抽取。
方法的返回值类型定义为 什么？
方法的名字叫什么？
方法的形式参数列表定义为 什么？
…
一个方法就是一个独立的功能。

3、方法的定义

[修饰符列表] 返回值类型 方法名(形式参数列表){
	方法体; 
}

4、方法的每一个细节学习
4.1、修饰符列表：可选项，目前先写成：public static
4.2、怎么理解返回值？返回值是一个方法执行结束之后的结果。
4.3、返回值类型都可以指定哪些类型？
4.4、返回值和“return语句”的关系。
4.5、方法名只要是合法的标识符就行，首字母小写，后面每个单词首字母大写。见名知意。
4.6、形式参数列表
4.7、方法体：方法体当中的代码遵循自上而下的顺序依次逐行执行。
4.8、方法怎么调用？“类名.”什么时候可以省略？
实际参数列表，简称实参。（调用方法时传递的实际数据。）
实参和形参的关系是一一对应。
1.方法重载overload

1.1、什么情况下我们考虑使用方法重载机制？
	当功能相似的时候，建议将方法名定义为一致的，
	这样代码美观，又方便编程。

	注意：如果功能不相似，坚决要让方法名不一致。

1.2、代码满足什么条件的时候构成了方法重载？
	条件1：在同一个类当中
	条件2：方法名相同
	条件3：形式参数列表不同（类型、个数、顺序）

	注意：
		方法重载和返回值类型无关，和修饰符列表无关。

1.3、方法重载的优点？
	代码美观
	方便代码的编写

2、方法递归

2.1、需要理解什么是方法递归？
	方法自身调用自身。

2.2、使用递归的时候，必须添加结束条件，没有结束条件，会发生栈内存溢出错误。
	StackOverflowError
	原因：一直压栈，没有弹栈，栈内存不够用。

2.3、会画出递归方法的内存结构图。
	递归的过程当中可以将图画出来。

2.4、能够使用循环代替递归的尽量使用循环，循环的执行耗费内存少一些，
递归耗费内存相对多一些，另外递归使用不当很容易内存溢出，JVM停止工作。
当然，只有极少数情况下，只能用递归，其它代码解决不了问题。

2.5、当递归有结束条件，并且结束条件合法的时候，就一定不会内存溢出吗？
	也不一定。可能递归的太深了。

2.6、分享了一些递归方面的经验
	在实际的开发中遇到递归导致的栈内存溢出错误是怎么办？
		第一步：先检查结束条件是否正确。
		第二步：如果正确，可以调整JVM的栈内存大小。(java -X)

5.面向对象

1、面向对象包括三大特征
封装
继承
多态

任何一个面向对象的编程语言都包括这三个特征
例如：
	python也有封装 继承 多态。
	java也有封装 继承 多态。

	注意：java只是面向对象编程语言中的一种。
	除了java之外，还有其它很多很多的编程语言也是面向对象的。

以上三个特征的名字先背会，后面一个一个进行学习。

2、类和对象的概念

面向对象当中最主要“一词”是：对象。

什么是类？
	类实际上在现实世界当中是不存在的，是一个抽象的概念。
	是一个模板。是我们人类大脑进行“思考、总结、抽象”的一个
	结果。(主要是因为人类的大脑不一般才有了类的概念。)
	...

3、类的定义
3.1、怎么定义一个类，语法格式是什么？
[修饰符列表] class 类名 {
//类体 = 属性 + 方法
// 属性在代码上以“变量”的形式存在（描述状态）
// 方法描述动作/行为
}

	注意：修饰符列表可以省略。
	方法体外声明的变量：成员变量。（这里的成员变量就是“属性”）

4、在语法级别上是怎么完成对象创建的呢？
类名 变量名 = new 类名();
这样就完成了对象的创建。

5、什么是实例变量？
对象又被称为实例。
实例变量实际上就是：对象级别的变量。
public class 明星类{
double height;
}
身高这个属性所有的明星对象都有，但是每一个对象都有“自己的身高值”。
假设创建10个明星对象，height变量应该有10份。
所以这种变量被称为对象级别的变量。属于实例变量。

实例变量在访问的时候，是不是必须先创建对象？

6、对象和引用的区别？
对象是通过new出来的，在堆内存中存储。
引用是：但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象的。

	方法覆盖
	1、什么时候考虑使用方法覆盖？
	父类中的方法无法满足子类的业务需求，子类有必要对继承过来的方法进行覆盖。

	2、什么条件满足的时候构成方法覆盖？
	第一：有继承关系的两个类
	第二：具有相同方法名、返回值类型、形式参数列表
	第三：访问权限不能更低。
	第四：抛出异常不能更多。
	3、关于Object类中toString()方法的覆盖？
	toString()方法存在的作用就是：将java对象转换成字符串形式。
	大多数的java类toString()方法都是需要覆盖的。因为Object类中提供的toString()
	方法输出的是一个java对象的内存地址。

	4、方法重载和方法覆盖有什么区别？
	方法重载发生在同一个类当中。
	方法覆盖是发生在具有继承关系的父子类之间。
	方法重载是一个类中，方法名相同，参数列表不同。
	方法覆盖是具有继承关系的父子类，并且重写之后的方法必须和之前的方法一致：
	方法名一致、参数列表一致、返回值类型一致。
	
    继承extends
1、什么是继承，有什么用？
	继承：在现实世界当中也是存在的，例如：父亲很有钱，儿子不用努力也很有钱。
	继承的作用：
		基本作用：子类继承父类，代码可以得到复用。（这个不是重要的作用，是基本作用。）
		主要(重要)作用：因为有了继承关系，才有了后期的方法覆盖和多态机制。

2、继承的相关特性
	① B类继承A类，则称A类为超类(superclass)、父类、基类，
	B类则称为子类(subclass)、派生类、扩展类。
		class A{}
		class B extends A{}
		我们平时聊天说的比较多的是：父类和子类。
		superclass 父类
		subclass 子类
		
    多态
    1、向上转型和向下转型的概念。
	向上转型：子--->父 (upcasting)
		又被称为自动类型转换：Animal a = new Cat()
	向下转型：父--->子 (downcasting)
		又被称为强制类型转换：Cat c = (Cat)a; 需要添加强制类型转换符。
		什么时候需要向下转型？
			需要调用或者执行子类对象中特有的方法。
			必须进行向下转型，才可以调用。
		向下转型有风险吗？
			容易出现ClassCastException（类型转换异常）
		怎么避免这个风险？
			instanceof运算符，可以在程序运行阶段动态的判断某个引用指向的对象
			是否为某一种类型。
	不管是向上转型还是向下转型，首先他们之间必须有继承关系，这样编译器就不会报错。
2、什么是多态。
	多种形态，多种状态，编译和运行有两个不同的状态。
	编译期叫做静态绑定。
	运行期叫做动态绑定。
	Animal a = new Cat();
	a.move();
3、什么时候必须进行向下转型？
	调用子类对象上特有的方法时。

super关键字
super能出现在实例方法和构造方法中。
super的语法是：“super.”、“super()”
super不能使用在静态方法中。
super. 大部分情况下是可以省略的。
super.什么时候不能省略呢？
	父类和子类中有同名属性，或者说有同样的方法，
	想在子类中访问父类的，super. 不能省略。
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中
的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。
super的使用：
	super.属性名				【访问父类的属性】
	super.方法名(实参)		【访问父类的方法】
	super(实参)					【调用父类的构造方法】
	
	final关键字
1、final修饰的类无法继承。
2、final修饰的方法无法覆盖。
3、final修饰的变量只能赋一次值。
4、final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用
指向的对象内部的数据是可以修改的。
5、final修饰的实例变量必须手动初始化，不能采用系统默认值。
6、final修饰的实例变量一般和static联合使用，称为常量。
		public static final double PI = 3.1415926;

抽象类和接口以及抽象类和接口的区别。
	1、抽象类
		第一：抽象类怎么定义？在class前添加abstract关键字就行了。
		第二：抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
		第三：final和abstract不能联合使用，这两个关键字是对立的。
		第四：抽象类的子类可以是抽象类。也可以是非抽象类。
		第五：抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
		第六：抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
		第七：抽象方法怎么定义？
			public abstract void doSome();
		第八：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。
	2、接口的基础语法。
		1、接口是一种“引用数据类型”。
		2、接口是完全抽象的。
		3、接口怎么定义：[修饰符列表] interface 接口名{}
		4、接口支持多继承。
		5、接口中只有常量+抽象方法。
		6、接口中所有的元素都是public修饰的
		7、接口中抽象方法的public abstract可以省略。
		8、接口中常量的public static final可以省略。
		9、接口中方法不能有方法体。
		3、接口在开发中的作用

	注意：接口在开发中的作用，类似于多态在开发中的作用。

	多态：面向抽象编程，不要面向具体编程。降低程序的耦合度。提高程序的扩展力。
		/*
		public class Master{
			public void feed(Dog d){}
			public void feed(Cat c){}
		}
		*/
		public class Master{
			public void feed(Animal a){
				// 面向Animal父类编程，父类是比子类更抽象的。
				//所以我们叫做面向抽象编程，不要面向具体编程。
				//这样程序的扩展力就强。
			}
		}

package和import

1、package
	第一：package出现在java源文件第一行。
	第二：带有包名怎么编译？javac -d . xxx.java
	第三：怎么运行？java 完整类名

	补充：以后说类名的时候，如果带着包名描述，表示完整类名。
	如果没有带包，描述的话，表示简类名。
		java.util.Scanner 完整类名。
		Scanner 简类名

2、import
	import什么时候不需要？
		java.lang不需要。
		同包下不需要。 
		其它一律都需要。
	怎么用？
		import 完整类名;
		import 包名.*;
		import java.util.Scanner; // 完整类名	
			
    访问控制权限
1、访问控制权限都有哪些？
	4个。
	private	私有
	public 公开
	protected	受保护
	默认

2、以上的4个访问控制权限：控制的范围是什么？
	private 表示私有的，只能在本类中访问
	public 表示公开的，在任何位置都可以访问
	“默认”表示只能在本类，以及同包下访问。
	protected表示只能在本类、同包、子类中访问。

	访问控制修饰符			本类			同包			子类			任意位置
	---------------------------------------------------------------------------
	public					可以			可以			可以			可以
	protected				可以			可以			可以			不行
	默认						可以			可以			不行			不行
	private					可以			不行			不行			不行

	范围从大到小排序：public > protected > 默认 > private
3、访问控制权限修饰符可以修饰什么？
	属性（4个都能用）
	方法（4个都能用）
	类（public和默认能用，其它不行。）
	接口（public和默认能用，其它不行。）

JDK类库的根类：Object

1、这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。
任何一个类默认继承Object。就算没有直接继承，最终也会间接继承。
2、Object类当中有哪些常用的方法？
	我们去哪里找这些方法呢？
		第一种方法：去源代码当中。（但是这种方式比较麻烦，源代码也比较难）
		第二种方法：去查阅java的类库的帮助文档。
		什么是API？
		应用程序编程接口。（Application Program Interface）
		整个JDK的类库就是一个javase的API。
		每一个API都会配置一套API帮助文档。
		SUN公司提前写好的这套类库就是API。（一般每一份API都对应一份API帮助文档。）	
			protected Object clone()   // 负责对象克隆的。
		int hashCode()	// 获取对象哈希值的一个方法。
		boolean equals(Object obj)  // 判断两个对象是否相等
		String toString()  // 将对象转换成字符串形式
		protected void finalize()  // 垃圾回收器负责调用的方法
3、toString()方法
	以后所有类的toString()方法是需要重写的。
	重写规则，越简单越明了就好。
	System.out.println(引用); 这里会自动调用“引用”的toString()方法。
	String类是SUN写的，toString方法已经重写了。
4、equals()方法
	以后所有类的equals方法也需要重写，因为Object中的equals方法比较
	的是两个对象的内存地址，我们应该比较内容，所以需要重写。
	基本数据类型比较实用：==
	对象和对象比较：调用equals方法

	String类是SUN编写的，所以String类的equals方法重写了。
	以后判断两个字符串是否相等，最好不要使用==，要调用字符串对象的equals方法。
	注意：重写equals方法的时候要彻底。
5、finalize()方法。
	这个方法是protected修饰的，在Object类中这个方法的源代码是？
		protected void finalize() throws Throwable { }

6 数组

1、常见的算法：
	排序算法：
		冒泡排序算法
		选择排序算法
	查找算法：
		二分法查找
2、算法实际上在java中不需要精通，因为java中已经封装好了，
要排序就调用方法就行。例如：java中提供了一个数组工具类：
	java.util.Arrays
		Arrays是一个工具类。
		其中有一个sort()方法，可以排序。静态方法，直接使用类名调用就行。

3、冒泡排序：

参与比较的数据：9 8 10 7 6 0 11
第1次循环：
8 9 10 7 6 0 11 (第1次比较：交换)
8 9 10 7 6 0 11 (第2次比较：不交换)
8 9 7 10 6 0 11 (第3次比较：交换)
8 9 7 6 10 0 11 (第4次比较：交换)
8 9 7 6 0 10 11 (第5次比较：交换)
8 9 7 6 0 10 11 (第6次比较：不交换)
最终冒出的最大数据在右边：11

参与比较的数据：8 9 7 6 0 10
第2次循环：
8 9 7 6 0 10（第1次比较：不交换）
8 7 9 6 0 10（第2次比较：交换）
8 7 6 9 0 10（第3次比较：交换）
8 7 6 0 9 10（第4次比较：交换）
8 7 6 0 9 10（第5次比较：不交换）

参与比较的数据：8 7 6 0 9
第3次循环：
7 8 6 0 9（第1次比较：交换）
7 6 8 0 9（第2次比较：交换）
7 6 0 8 9（第3次比较：交换）
7 6 0 8 9（第4次比较：不交换）

参与比较的数据：7 6 0 8
第4次循环：
6 7 0 8（第1次比较：交换）
6 0 7 8（第2次比较：交换）
6 0 7 8（第3次比较：不交换）

参与比较的数据：6 0 7
第5次循环：
0 6 7（第1次比较：交换）
0 6 7（第2次比较：不交换）

参与比较的数据：0 6
第6次循环：
0 6 （第1次比较：不交换）

for(int i = 6; i > 0; i--){ // 6次
	//7条数据比6次
	//6条数据比5次
	//5条数据比4次
	//4条数据比3次
	//3条数据比2次
	//2条数据比1次
	for(int j = 0; j < i; j++){
	
	}
}

4、选择排序：

选择排序比冒泡排序的效率高。
高在交换位置的次数上。
选择排序的交换位置是有意义的。

循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的值和
最前面的数据“交换位置”。


参与比较的数据：3 1 6 2 5 （这一堆参加比较的数据中最左边的元素下标是0）
第1次循环之后的结果是：
1 3 6 2 5 

参与比较的数据：3 6 2 5 （这一堆参加比较的数据中最左边的元素下标是1）
第2次循环之后的结果是：
2 6 3 5 

参与比较的数据：6 3 5 （这一堆参加比较的数据中最左边的元素下标是2）
第3次循环之后的结果是：
3 6 5 

参与比较的数据：6 5 （这一堆参加比较的数据中最左边的元素下标是3）
第4次循环之后的结果是：
5 6

注意：5条数据，循环4次。

5、二分法查找（折半查找）：

第一：二分法查找建立在排序的基础之上。
第二：二分法查找效率要高于“一个挨着一个”的这种查找方式。
第三：二分法查找原理？
	10(0下标) 23 56 89 100 111 222 235 500 600(下标9) arr数组
	
	目标：找出600的下标
		(0 + 9) / 2 --> 4（中间元素的下标）
	
	arr[4]这个元素就是中间元素：arr[4]是 100
	100 < 600
	说明被查找的元素在100的右边。
	那么此时开始下标变成：4 + 1

		(5 + 9) / 2 --> 7（中间元素的下标）
		arr[7] 对应的是：235
		235 < 600
		说明被查找的元素在235的右边。
	
	开始下标又进行了转变：7 + 1
		(8 + 9) / 2 --> 8
		arr[8] --> 500
		500 < 600
		开始元素的下标又发生了变化：8 + 1
		(9 + 9) / 2 --> 9
		arr[9]是600，正好和600相等，此时找到了。
 
**5 异常机制**
   1.1、异常在java中以类和对象的形式存在。那么异常的继承结构是怎样的？
	Object下有Throwable（可抛出的）
	Throwable下有两个分支：Error（不可处理，直接退出JVM）和Exception（可处理的）
	Exception下有两个分支：
		Exception的直接子类：编译时异常（要求程序员在编写程序阶段必须预先对这些异常进行处理，如果不处理编译器报错，因此得名编译时异常。）。
		RuntimeException：运行时异常。（在编写程序阶段程序员可以预先处理，也可以不管，都行。）

1.2、编译时异常和运行时异常，都是发生在运行阶段。编译阶段异常是不会发生的。
编译时异常因为什么而得名？
	因为编译时异常必须在编译(编写)阶段预先处理，如果不处理编译器报错，因此得名。
	所有异常都是在运行阶段发生的。因为只有程序运行阶段才可以new对象。
	因为异常的发生就是new异常对象。
1.3、编译时异常和运行时异常的区别？
	编译时异常一般发生的概率比较高。
			对于一些发生概率较高的异常，需要在运行之前对其进行预处理。
	运行时异常一般发生的概率比较低
1.4、编译时异常还有其他名字：
	受检异常：CheckedException
	受控异常
1.5、运行时异常还有其它名字：
	未受检异常：UnCheckedException
	非受控异常
1.6、所有异常都是发生在运行阶段的。
1.7、Java语言中对异常的处理包括两种方式：
	第一种方式：在方法声明的位置上，使用throws关键字，抛给上一级。
		谁调用我，我就抛给谁。抛给上一级。
	第二种方式：使用try..catch语句进行异常的捕捉。
		这件事发生了，谁也不知道，因为我给抓住了。
1.8、注意：Java中异常发生之后如果一直上抛，最终抛给了main方法，main方法继续
向上抛，抛给了调用者JVM，JVM知道这个异常发生，只有一个结果。终止java程序的执行。

7 常用API

    String类。
1.1、对String在内存存储方面的理解：
	第一：字符串一旦创建不可变。
	第二：双引号括起来的字符串存储在字符串常量池中。
	第三：字符串的比较必须使用equals方法。
	第四：String已经重写了toString()和equals()方法。
1.2、String的构造方法。
	String s = "abc";
	String s = new String("abc");
	String s = new String(byte数组);
	String s = new String(byte数组, 起始下标, 长度);
	String s = new String(char数组);
	String s = new String(char数组, 起始下标, 长度);
1.3、String类常用的21个方法。

2、StringBuffer/StringBuilder
	2.1、StringBuffer/StringBuilder可以看做可变长度字符串。
	2.2、StringBuffer/StringBuilder初始化容量16.
	2.3、StringBuffer/StringBuilder是完成字符串拼接操作的，方法名：append
	2.4、StringBuffer是线程安全的。StringBuilder是非线程安全的。
	2.5、频繁进行字符串拼接不建议使用“+”
3、八种基本数据类型对应的包装类。
3.1、什么是自动装箱和自动拆箱，代码怎么写？
	Integer x = 100; // x里面并不是保存100，保存的是100这个对象的内存地址。
	Integer y = 100;
	System.out.println(x == y); // true

	Integer x = 128;
	Integer y = 128;
	System.out.println(x == y); // false

3.2、Integer类常用方法。
	Integer.valueOf()
	Integer.parseInt("123")
	Integer.parseInt("中文") : NumberFormatException

3.3、Integer String int三种类型互相转换。

4、日期类
	4.1、获取系统当前时间
		Date d = new Date();
	4.2、日期格式化：Date --> String
		yyyy-MM-dd HH:mm:ss SSS
		SimpleDateFormat sdf = new SimpleDate("yyyy-MM-dd HH:mm:ss SSS");
		String s = sdf.format(new Date());
	4.3、String --> Date
		SimpleDateFormat sdf = new SimpleDate("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse("2008-08-08 08:08:08");
	4.4、获取毫秒数
		long begin = System.currentTimeMillis();
		Date d = new Date(begin - 1000 * 60 * 60 * 24);

5、数字类
	5.1、DecimalFormat数字格式化
		###,###.## 表示加入千分位，保留两个小数。
		###,###.0000 表示加入千分位，保留4个小数，不够补0
	5.2、BigDecimal
		财务软件中通常使用BigDecimal

6、随机数
	6.1、怎么产生int类型随机数。
		Random r = new Random();
		int i = r.nextInt();
	6.2、怎么产生某个范围之内的int类型随机数。
		Random r = new Random();
		int i = r.nextInt(101); // 产生[0-100]的随机数。

7、枚举
	7.1、枚举是一种引用数据类型。
	7.2、枚举编译之后也是class文件。
	7.3、枚举类型怎么定义？
		enum 枚举类型名{
			枚举值,枚举值2,枚举值3
		}
	7.4、当一个方法执行结果超过两种情况，并且是一枚一枚可以列举出来
	的时候，建议返回值类型设计为枚举类型。

8、异常处理机制
	8.1、java中异常的作用是：增强程序健壮性。
	8.2、java中异常以类和对象的形式存在。

8 集合

1.1、什么是集合？有什么用？

	数组其实就是一个集合。集合实际上就是一个容器。可以来容纳其它类型的数据。
	集合为什么说在开发中使用较多？
		集合是一个容器，是一个载体，可以一次容纳多个对象。
		在实际开发中，假设连接数据库，数据库当中有10条记录，
		那么假设把这10条记录查询出来，在java程序中会将10条
		数据封装成10个java对象，然后将10个java对象放到某一个
		集合当中，将集合传到前端，然后遍历集合，将一个数据一个
		数据展现出来。
1.2、集合不能直接存储基本数据类型，另外集合也不能直接存储java对象，
集合当中存储的都是java对象的内存地址。（或者说集合中存储的是引用。）
	list.add(100); //自动装箱Integer
	注意：
		集合在java中本身是一个容器，是一个对象。
		集合中任何时候存储的都是“引用”。

1.3、在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中
存储元素，等于将数据放到了不同的数据结构当中。什么是数据结构？数据存储的
结构就是数据结构。不同的数据结构，数据存储方式不同。例如：
	数组、二叉树、链表、哈希表...
	以上这些都是常见的数据结构。
	你往集合c1中放数据，可能是放到数组上了。
	你往集合c2中放数据，可能是放到二叉树上了。
	你使用不同的集合等同于使用了不同的数据结构。

	new ArrayList(); 创建一个集合，底层是数组。
	new LinkedList(); 创建一个集合对象，底层是链表。
	new TreeSet(); 创建一个集合对象，底层是二叉树。

1、List接口中的常用方法。
List是Collection接口的子接口。所以List接口中有一些特有的方法。
void add(int index, Object element)
Object set(int index, Object element)
Object get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
Object remove(int index)
2、迭代器迭代元素的过程中不能使用集合对象的remove方法删除元素，
要使用迭代器Iterator的remove方法来删除元素，防止出现异常：
ConcurrentModificationException
3、ArrayList
ArrayList集合初始化容量10
扩容为原容量1.5倍。
底层是数组。
数组优点和缺点要能够说出来！
另外要注意：ArrayList集合末尾增删元素效率还是可以的。
4、链表数据结构
第一：单向链表和双向链表数据结构要理解。
第二：链表数据结构的优点和缺点要能够说出来。
5、泛型：集合使用泛型来减少向下转型的操作。
6
foreach
对数组怎么遍历？
for(int i : arr){
System.out.println(i);
}
对集合怎么遍历？
for(String s : list){
System.out.println(s);
}
List list = new ArrayList<>();

1、掌握Map接口中常用方法。

2、遍历Map集合的两种方式都要精通。
第一种：获取所有key，遍历每个key，通过key获取value.
第二种：获取Set<Map.Entry>即可，遍历Set集合中的Entry
调用entry.getKey() entry.getValue()

3、了解哈希表数据结构。

4、存放在HashMap集合key部分和HashSet集合中的元素需要同时重写hashCode和equals。

5、HashMap和Hashtable的区别。
HashMap：
初始化容量16，扩容2倍。
非线程安全
key和value可以为null。

Hashtable
	初始化容量11，扩容2倍+1
	线程安全
	key和value都不能是null。

6、Properties类的常用两个方法。
setProperty
getProperty

7、了解自平衡二叉树数据结构。
左小右大原则存储。
中序遍历方式。

8、TreeMap的key或者TreeSet集合中的元素要想排序，有两种实现方式：
第一种：实现java.lang.Comparable接口。
第二种：单独编写一个比较器Comparator接口。

9、集合工具类Collections:
synchronizedList方法
sort方法（要求集合中元素实现Comparable接口。）

9 IO

    2、IO流，什么是IO？
I : Input
O : Output
通过IO可以完成硬盘文件的读和写。

3、IO流的分类？

有多种分类方式：
	一种方式是按照流的方向进行分类：
		以内存作为参照物，
			往内存中去，叫做输入(Input)。或者叫做读(Read)。
			从内存中出来，叫做输出(Output)。或者叫做写(Write)。
	另一种方式是按照读取数据方式不同进行分类：
		有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。
		这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件等..
		有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取
		普通文本文件而存在的，这种流不能读取：图片、声音、视频等文件。只能读取纯
		文本文件，连word文件都无法读取	
流的分类
	输入流、输出流
	字节流、字符流

5、
java.io.InputStream 字节输入流
java.io.OutputStream 字节输出流
java.io.Reader 字符输入流
java.io.Writer 字符输出流
所有的流都实现了：
java.io.Closeable接口，都是可关闭的，都有close()方法。
流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，
不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。
所有的输出流都实现了：
java.io.Flushable接口，都是可刷新的，都有flush()方法。
注意：如果没有flush()可能会导致丢失数据。
注意：在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。

**10 多线程**
1、什么是进程？什么是线程？
	进程是一个应用程序（1个进程是一个软件）。
	线程是一个进程中的执行场景/执行单元。
	一个进程可以启动多个线程。	
2、对于java程序来说，当在DOS命令窗口中输入：
	java HelloWorld 回车之后。
	会先启动JVM，而JVM就是一个进程。
	JVM再启动一个主线程调用main方法。
	同时再启动一个垃圾回收线程负责看护，回收垃圾。
	最起码，现在的java程序中至少有两个线程并发，
	一个是垃圾回收线程，一个是执行main方法的主线程。
3、第一种方式：编写一个类，直接继承java.lang.Thread，重写run方法。
	// 定义线程类
	public class MyThread extends Thread{
		public void run(){
		
		}
	}
	// 创建线程对象
	MyThread t = new MyThread();
	// 启动线程。
	t.start();

第二种方式：编写一个类，实现java.lang.Runnable接口，实现run方法。
	// 定义一个可运行的类
	public class MyRunnable implements Runnable {
		public void run(){
		
		}
	}
	// 创建线程对象
	Thread t = new Thread(new MyRunnable());
	// 启动线程
	t.start();

注意：第二种方式实现接口比较常用，因为一个类实现了接口，它还可以去继承
其它的类，更灵活。

4、关于线程对象的生命周期？
	新建状态
	就绪状态
	运行状态
	阻塞状态
	死亡状态
 5、死锁

 	/**
 * 死锁 : 线程在执行中,遇到了对方进入了加锁的方法,从而导致大家都访问不了的状态
 * 
 * 原理 : 
 * 		1 某个线程执行完成,需要 先后 嵌套  锁定  执行两个对象,在这个过程中,先锁定第一个对象
 * 		2 另外一个线程执行完成 需要 先后 嵌套 锁定 执行两个对象,在这个过程中,先锁定第二个对象
 * 		3 第一个线程执行到第二个对象的时候,发现已经被第二个线程锁定,只能等待
 * 		3 第二线程执行到第一个对象的时候,发现已经被第一个线程锁定,只能等待
 * 
 * 如果访问一个代码块锁的时候
 * 		如果该代码块锁的是对象,那么锁该对象的代码块锁 以及 该对象 所有加锁 的成员方法 都会被锁定
 * 		如果该代码块锁的是类,那么所有锁该类的代码块锁 以及 该类中 所有加锁的 静态方法 都会被锁定
 * 
 * 
 * @author 天亮教育-帅气多汁你泽哥
 * @Date 2021年4月19日
 */
public class Thread_02_DeadLock {
	public static void main(String[] args) {
		Object o1 = new Object();
		Object o2 = new Object();
		Thread t1 = new T1(o1,o2);
		Thread t2 = new Thread(new T2(o1,o2));
		t1.start();
		t2.start();
	}
}

class T1 extends Thread {
	Object o1;
	Object o2;

	public T1(Object o1, Object o2) {
		super();
		this.o1 = o1;
		this.o2 = o2;
	}

	@Override
	public void run() {
		synchronized (o1) {
			try {
				// 睡眠一会,保证让t2去锁住o2
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (o2) {
				System.out.println("T1执行完成");
			}
		}
	}
}

class T2 implements Runnable {
	Object o1;
	Object o2;

	public T2(Object o1, Object o2) {
		super();
		this.o1 = o1;
		this.o2 = o2;
	}

	@Override
	public void run() {

		synchronized (o2) {
			try {
				// 睡眠一会,保证让t1锁住o1
				Thread.sleep(10);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			synchronized (o1) {
				System.out.println("T2执行完成");
			}
		}

	}
}

10 网络编程

  1、网络编程概述
Java是 Internet 上的语言，它从语言级上提供了对网络应用程 序的支持，程序员能够很容易开发常见的网络应用程序。
Java提供的网络类库，可以实现无痛的网络连接，联网的底层 细节被隐藏在 Java 的本机安装系统里，由 JVM 进行控制。并 且 Java 实现了一个跨平台的网络库，程序员面对的是一个统一 的网络编程环境。

2、网络基础
计算机网络：
把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规 模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、 共享硬件、软件、数据信息等资源。
网络编程的目的：
直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。
网络编程中有两个主要的问题：
如何准确地定位网络上一台或多台主机；定位主机上的特定的应用
找到主机后如何可靠高效地进行数据传输
3、网络通信
通信双方地址
a)IP
b)端口号
一定的规则（即：网络通信协议。有两套参考模型）
c)OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
d)TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准。
2.1.通信要素1：IP地址
IP 地址：InetAddress
唯一的标识 Internet 上的计算机（通信实体）
本地回环地址(hostAddress)：127.0.0.1	主机名(hostName)：localhost
IP地址分类方式1：IPV4 和 IPV6
IPV4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。以点分十进制表示，如192.168.0.1
IPV6：128位（16个字节），写成8个无符号整数，每个整数用四个十六进制位表示， 数之间用冒号（：）分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
IP地址分类方式2：公网地址(万维网使用)和私有地址(局域网使用)。192.168.  开头的就是私有址址，范围即为192.168.0.0--192.168.255.255，专门为组织机 构内部使用
特点：不易记忆
2.2.通信要素2：端口号
端口号标识正在计算机上运行的进程（程序）
不同的进程有不同的端口号
被规定为一个 16 位的整数 0~65535。
端口分类：
公认端口：0~1023。被预先定义的服务通信占用（如：HTTP占用端口80，FTP占用端口21，Telnet占用端口23）
注册端口：1024~49151。分配给用户进程或应用程序。（如：Tomcat占用端口8080，MySQL占用端口3306，Oracle占用端口1521等）。
动态/私有端口：49152~65535。
端口号与IP地址的组合得出一个网络套接字：Socket。
4、网络协议
4.1.TCP/IP协议簇
传输层协议中有两个非常重要的协议：
传输控制协议TCP(Transmission Control Protocol)
用户数据报协议UDP(User Datagram Protocol)。
TCP/IP 以其两个主要协议：传输控制协议(TCP)和网络互联协议(IP)而得名，实际上是一组协议，包括多个具有不同功能且互为关联的协议。
IP(Internet Protocol)协议是网络层的主要协议，支持网间互连的数据通信。
TCP/IP协议模型从更实用的角度出发，形成了高效的四层体系结构，即物理链路层、IP层、传输层和应用层。

4.1.1.Socket
利用套接字(Socket)开发网络应用程序早已被广泛的采用，以至于成为事实 上的标准。
网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标 识符套接字。
通信的两端都要有Socket，是两台机器间通信的端点。
网络通信其实就是Socket间的通信。
Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输。
一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。
Socket分类：
流套接字（stream socket）：使用TCP提供可依赖的字节流服务数据报套接字（datagram socket）：使用UDP提供“尽力而为”的数据报服务
4.1.2.常用方法
Socket类的常用构造器：
public Socket(InetAddress address,int port)创建一个流套接字并将其连接到指定IP 地址的指定端口号。
public Socket(String host,int port)创建一个流套接字并将其连接到指定主机上的指定端口号。
Socket类的常用方法：
public InputStream getInputStream()返回此套接字的输入流。可以用于接收网络消息
public OutputStream getOutputStream()返回此套接字的输出流。可以用于发送网络消息
public InetAddress getInetAddress()此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。
public InetAddress getLocalAddress()获取套接字绑定的本地地址。 即本端的IP地址
public int getPort()此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。
public int getLocalPort()返回此套接字绑定到的本地端口。 如果尚未绑定套接字，则返回 -1。即本端的 端口号。
public void close()关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接 或重新绑定）。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。
public void shutdownInput()如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将 返回EOF（文件结束符）。 即不能在从此套接字的输入流中接收任何数据。
public void shutdownOutput()禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发 送，并且后跟 TCP 的正常连接终止序列。 如果在套接字上调用 shutdownOutput() 后写入套接字输出流，  则该流将抛出 IOException。 即不能通过此套接字的输出流发送任何数据。
4.1.3.客户端服务端创建
客户端Socket的工作过程包含以下四个基本的步骤：
创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
打开连接到Socket 的输入/出流： 使用 getInputStream()方法获得输入流，使用 getOutputStream()方法获得输出流，进行数据传输
按照一定的协议对Socket 进行读/写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。
关闭 Socket：断开客户端到服务器的连接，释放线路

客户端程序可以使用Socket类创建对象，创建的同时会自动向服务器方发起连 接。Socket的构造器是：
Socket(String host,int port)throws UnknownHostException,IOException：向服务器(域名是host。端口号为port)发起TCP连接，若成功，则创建Socket对象，否则抛出异常。
Socket(InetAddress address,int port)throws IOException：根据InetAddress对象所表示的 IP地址以及端口号port发起连接。
客户端建立socketAtClient对象的过程就是向服务器发出套接字连接请求

Socket s = new Socket(“192.168.40.165”,9999);
OutputStream out = s.getOutputStream();  out.write(" hello".getBytes());
s.close();

服务器程序的工作过程包含以下四个基本的步骤：
调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口 上。用于监听客户端的请求。
调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信 套接字对象。
调用 该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。
关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。

ServerSocket 对象负责等待客户端请求建立套接字连接，类似邮局某个窗口 中的业务员。也就是说，服务器必须事先建立一个等待客户请求建立套接字 连接的ServerSocket对象。
所谓“接收”客户的套接字请求，就是accept()方法会返回一个 Socket 对象