华清远见-重庆中心-JAVA高级阶段技术总结

正则表达式	说明
[abc]	a、b、c中任意一个字符
[^abc]	除了a、b、c的任意字符
[a-z]	a、b、C、.....、z中的任意一个字符
[a-zA-Z0-9]	a~z、A~Z、0~9中任意一个字符
[a-z&&[ ^bc]]	a~z中除了b和c意外的任意一个字符，其中&&表示“与”的关系

正则表达式	说明
.	任意一个字符
\d	任意一个数字字符，相当于[0-9]
\D	任意一个非数字字符，相当于[ ^O-9]
\s	空白字符，相当于[\t\n\xOB\f\r]
\S	非空白字符，相当于[ ^\s]
\w	任意一个单词字符,相当于[a-zA-Z_0-9]
\W	任意一个非单词字符，相当于[ ^\w]

正则表达式	功能描述
X?	表示0个或1个X
X*	表示0个或任意多个X
X+	表示1个到任意多个X(大于等于1个X）
X{n}	表示n个X
X{n, }	表示n个到任意多个X(大于等于n个X)
X{n,m}	表示n个到m个X(大于等于n个且小于m个X)

提示：以下是本篇文章正文内容，下面案例可供参考

一、jdk提供的类

JDK(Java Development Kit) 是 Java 语言的软件开发工具包(SDK)。
SE(JavaSE)，standard edition，标准版，是我们通常用的一个版本，从JDK 5.0开始，改名为Java SE。
EE(JavaEE)，enterprise edition，企业版，使用这种JDK开发J2EE应用程序，从JDK 5.0开始，改名为Java EE。从2018年2月26日开始，J2EE改名为Jakarta EE [1] 。
ME(J2ME)，micro edition，主要用于移动设备、嵌入式设备上的java应用程序，从JDK 5.0开始，改名为Java ME。

JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。

1、JDK基本组件

javac – 编译器，将源程序转成字节码
jar – 打包工具，将相关的类文件打包成一个文件
javadoc – 文档生成器，从源码注释中提取文档
jdb – debugger，查错工具
java – 运行编译后的java程序（.class后缀的）
appletviewer：小程序浏览器，一种执行HTML文件上的Java小程序的Java浏览器。
Javah：产生可以调用Java过程的C过程，或建立能被Java程序调用的C过程的头文件。
Javap：Java反汇编器，显示编译类文件中的可访问功能和数据，同时显示字节代码含义。
Jconsole: Java进行系统调试和监控的工具

2、JDK分类（包）

java.lang：这个是系统的基础类，比如String等都是这里面的，这个包是一个可以不用引入(import)就可以使用的包。
java.io：这里面是所有输入输出有关的类，比如文件操作等。
java.nio：为了完善io包中的功能，提高io包中性能而写的一个新包，例如NIO非堵塞应用
java.net: 这里面是与网络有关的类，比如URL，URLConnection等。
java.util：这个是系统辅助类，特别是集合类Collection，List，Map等。
java.sql：这个是数据库操作的类，Connection， Statement，ResultSet等。
javax.servlet：这个是JSP，Servlet等使用到的类。

2、Java数据类型

Java 语言支持的数据类型分为两种：

基本数据类型（Primitive Type）和引用数据类型（Reference Type）

1、基本数据类型（Primitive Type）

boolean（布尔型）、float（单精度浮点型）、char（字符型）、byte（字节型）、short（短整型）、int（整型）、long（长整型）和 double （双精度浮点型）

整数类型（包括 byte、short，int 和 long）
浮点类型（包括 float 和 double）
布尔类型和字符类型（char）

8种基本数据类型对应的包装类型名

参考于：Java 八大包装类

基本数据类型	包装类型
byte	java.lang.Byte（父类Number）
short	java.lang.Short（父类Number）
int	java.lang.Integer（父类Number）
long	java.lang.Long（父类Number）
float	java.lang.Float（父类Number）
double	java.lang.Double（父类Number）
boolean	java.lang.Boolean（父类Object）
char	java.lang.Character（父类Object）

(注意： 8种包装类属于 引用数据类型)

2、引用数据类型（Reference Type）

数组、类、接口 ------------- 默认值：null

（特殊的 null 类型：空引用（null）是 null 类型变量唯一的值。空引用（null）可以转换为任何引用类型。）

二、JAVA SE中主要的类与方法

附：java有关类的API详细文档查询网址

1.Object 类

1.1Object类的介绍

java.lang.Object类是所有类的父类。
Object类定义了“对象”的基本“行为”，被子类继承这些行为。
万事万物皆对象。
一个类定义的时候，没有使用extends继承某个特定父类，那么该类的父类就是Object.（隐式继承）

Object类的方法

1.2 toString

Object类中的toString方法，用于返回对象成员变量的字符串表示。
Object类中的toString方法的定义：

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

所有java类都有toString方法，通常会要求根据需要重写toString方法，返回更有意义的字符串。
System.out.println(obj) 等价于 System.out.println(obj.toString())

1.3 equals

Object类的equals方法，用于判断对象是否相等。
Object类equals方法的定义：

自己和某个对象进行比较。

public boolean equals(Object obj) {

return (this == obj);

}

子类中可以根据实际需求，自定义比较规则，然后重写equals方法。

1.4 hashCode

Object类的hashCode方法，根据对象的内容，返回一个整数值。

Returns a hash code value for the object 。

一般重写了 equals 方法，就会要求重写 hashCode 方法。

Object类hashCode方法的定义：

public native int hashCode();

1.5参考代码

import java.util.Objects;
// Student的父类： Object
// ** 重写父类的方法： toString , equals , hashCode
public class Student {
private String stuNo;
private String stuName;
private int stuAge;
public Student(){
}
public Student(String stuNo, String stuName, int stuAge) {
this.stuNo = stuNo;
2. String 类型
this.stuName = stuName;
this.stuAge = stuAge;
}
@Override
public String toString() {
return "Student{" +
"stuNo='" + stuNo + '\'' +
", stuName='" + stuName + '\'' +
", stuAge=" + stuAge +
'}';
}
@Override // 表示该方法必须是重写父类的方法。也就是说方法名字，返回值，参数都是和父类一致
的方法。
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Student)) return false;
Student student = (Student) o;
return stuAge == student.stuAge && Objects.equals(stuNo, student.stuNo)
&& Objects.equals(stuName, student.stuName);
}
@Override
public int hashCode() {
return Objects.hash(stuNo, stuName, stuAge);
}
public String getStuNo() {
return stuNo;
}
public void setStuNo(String stuNo) {
this.stuNo = stuNo;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public int getStuAge() {
return stuAge;
}
public void setStuAge(int stuAge) {
this.stuAge = stuAge;
}
}

2.String 类

String特性-不可变

java.lang.String中封装的是字符串序列。
String在内存中采用Unicode编码方式，一个字符两个字节的定长。
String对象创建之后，这个对象的内容(即对象中的字符串序列不可变)不可变化。

String str = “abc”;

str = str.toUpperCase(); // 创建了新的字符串对象 “ABC” ,str 指向新对象。

// 引用指向的对象变了，原来的对象 “abc” 不变。

System.out.println(str); // “ABC”

String特性-常量池

java中可以使用直接量，创建字符串对象。String str = "hello world.";
出于性能的考虑，jvm会将这些字符串字面量对象，保存在常量池中，对于重复出现的字符串直接量，jvm优先在缓存中查找，如果存在就直接返回该对象。

String str1 = “nice to meet you .”;

String str2 = “nice to meet you .”;

System.out.println(s1 == s2) ;// true.

String str3 = new String(“nice to meet you .”);

System.out.println(s3 == s2) ;// false.

便于理解附下图：以下“公共池”即为常量池

String-equals

String类中重写了equals方法，规则为:两个字符串的字符串序列相同，那么equals为true.
String类中定义了equalslgnoreCase，忽略大小写比较。

String的常见使用方法

String toLowerCase()	返回字符串的小写形式
String toUpperCase()	返回字符串的大写形式
String trim()	返回字符串为原始字符串去掉前导和后继的空白(空格\t \nr ...)
boolean startsWith(String prefix)	判断字符串是否以参数字符串开头
boolean endsWith(String suffix)	判断字符串是否以参数字符串结尾
int length()	返回字符串字符序列的长度

补充：String类的20种常见方法_Jacky_Cmd的博客-CSDN博客

3、可变字符串StringBuilder类和StringBuffer类

3.1StringBuilder

StringBuilder封装可变的字符串， StringBuilder对象创建后，可以通过调用方法，修改字符串的内容。

3.2StringBuffer

StringBuffer封装可变的字符串， StringBuffer对象创建后，可以通过调用方法，修改字符串的内容。
StringBuffer构造器函数

public StringBuffer();

public StringBuffer(String str);
StringBuffer提供的操作字符串的方法： append , insert , delete , replace,reverse等。
StringBuffer提供的很多方法，返回值是StringBuffer（return this ） , 所以支持链式操作：

StringBuffersb = new StringBuffer(“a”)；

sb.append(“b”).append(“b”)........

StringBuffer 类支持的主要方法：

1	public StringBuffer append(String s) 将指定的字符串追加到此字符序列。
2	public StringBuffer reverse() 将此字符序列用其反转形式取代。
3	public delete(int start, int end) 移除此序列的子字符串中的字符。
4	public insert(int offset, int i) 将 `int` 参数的字符串表示形式插入此序列中。
5	insert(int offset, String str) 将 `str` 参数的字符串插入此序列中。
6	replace(int start, int end, String str) 使用给定 `String` 中的字符替换此序列的子字符串中的字符。

1	int capacity() 返回当前容量。
2	char charAt(int index) 返回此序列中指定索引处的 `char` 值。
3	void ensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。
4	void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 `dst`。
5	int indexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。
6	int indexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。
7	int lastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。
8	int lastIndexOf(String str, int fromIndex) 返回 String 对象中子字符串最后出现的位置。
9	int length() 返回长度（字符数）。
10	void setCharAt(int index, char ch) 将给定索引处的字符设置为 `ch`。
11	void setLength(int newLength) 设置字符序列的长度。
12	CharSequence subSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。
13	String substring(int start) 返回一个新的 `String`，它包含此字符序列当前所包含的字符子序列。
14	String substring(int start, int end) 返回一个新的 `String`，它包含此序列当前所包含的字符子序列。
15	String toString() 返回此序列中数据的字符串表示形式。

3.3String、StringBuilder和StringBuffer的区别

如果要操作少量的数据，用String ；单线程操作大量数据，用StringBuilder ；多线程操作大量数据，用StringBuffer
StringBuilder是线程不安全的，而StringBuffer是线程安全的
String 为字符串常量，StringBuffer与StringBuilder字符串变量

4.Date & SimpleDateFormat

4.1Date

java.util.Date用于封装日期和时间信息。 Date date = new Date();
date中的日期为系统的当前时间。
重写了toString方法，输出内容为日期。
Date类中大多数用于操作时间分量的方法都被Calendar取代。
Date中的getTime , setTime方法是用于获取/设置时间毫秒数。

Date 对象创建以后，可以调用下面的方法。

序号	方法和描述
1	boolean after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
2	boolean before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
3	Object clone( ) 返回此对象的副本。
4	int compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
5	int compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
6	boolean equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
7	long getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
8	int hashCode( ) 返回此对象的哈希码值。
9	void setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
10	String toString( ) 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

4.2 SimpleDateFormat

将日期类型，格式化为指定日期表示的字符串。
将符合日期格式的字符串，解析为日期类型。
日期符号： yyyy 年， MM 月， dd , 日 , 时间： HH 小时， hh小时， mm ，分， ss 秒

SimpleDateFormat df = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");

parse()，它试图按照给定的SimpleDateFormat 对象的格式化存储来解析字符串

4.3Calendar类

java.util.Calendar类，用于封装日历信息，包含了日期，主要用于操作时间分量。
Calendar是抽象类，可以通过其工厂方法获取到其子类的对象。
java.util.GregorianCalendar是Calendar的最主要使用的实现类，其对应世界上大多数国家/地区使用的标准日历。

Calendar.YEAR	年份
Calendar.MONTH	月份
Calendar.DATE	日期
Calendar.DAY_OF_MONTH	日期，和上面的字段意义完全相同
Calendar.HOUR	12小时制的小时
Calendar.HOUR_OF_DAY	24小时制的小时
Calendar.MINUTE	分钟
Calendar.SECOND	秒
Calendar.DAY_OF_WEEK	星期几

5.包装类

Java设计中一个核心的原则，即万物皆对象，也就是说一切要求用对象的形式描述，但是基本数据类型不是对象。可以把基本数据类型包装成一个对象，以面向对象的思想去使用这些类型。

包装类就是原始类型对应的类类型。

所有包装类都重写了toString()方法，用于将包装类对象转换为String对象
java中的包装类提供了将原始数据类型转换为对象，以及将对象转换为原始数据类型的机制。
自动装箱和取消装箱功能将原始对象和对象自动转换为原始数据类型。将原始数据类型自动转换为对象称为自动装箱

装箱和拆箱

原始数据类型自动装箱和拆箱的工作和相应的包装类完全在编译器中实现。

从原始数据类型(byte, short, int, long, float, double, char 和 boolean)到其对应的包装器对象(Byte, Integer, Long, Float, Double, Character 和 Boolean)的自动包装称为自动装箱。
反向，从包装器对象到其对应的原始数据类型称为拆箱。

装箱：所有包装类都有一个静态方法valueOf(原始类型)，将某个原始类型的数据转换为相应的包装类对象。这个过程称为装箱。

拆箱：所有包装类都有一个原始类型Value()方法，用于将包装类对象转换为原始类型。这个过程称为拆箱。

包装类的常用方法

最大值，最小值
parseInt
parseDouble
toBinaryString (二进制)
toHexString(16进制)

六、BigDecimal & BigInteger

6.1BigDecimal

java 中的浮点数类型 (float , double) 在运算时会有舍入误差，如果希望得到精确的运算结果，可以

使用 java.math.BigDecimal 类

6.2BigInteger

dk 中提供的整数类型 (int ,long ) 的储值范围有限，当需要进行很大的整数运算时，可以使用

java.math.BigInteger ，理论上 BigInteger 数据范围只受内存容量的限定。

BigInteger 提供了： add , multiply,subtract,divide 等方法

七、集合与数组

数组和集合都用于存放一组数据，但数组的容量是固定大小的，而集合的容量是动态可变的；对于可存放的数据类型，数组既可以存放基本数据类型又可以存放引用数据类型，而集合只能存放引用数据类型，基本数据类型需要转换为对应的包装类才能存放到集合当中。

数组

数组是相同类型的数据按照顺序组成的一种引用数据类型。

数组是引用数据类型。它在创建时，会在内存中开辟一个连续的空间；数组是同一数据类型的集合。可以使用数组下标来引用数组元素，数组元素的下标都是从0开始，使用下标不要超出范围，否则会抛出异常。可以使用length属性获取数组的长度。

集合

无法预测存储数据的数量：由于数组容量是固定大小，因此使用集合存储动态数量的数据更为合适；
同时存储具有一对一关系的数据：例如存储慕课网学生的积分，为了方便检索对应学生的积分，可使用Map将慕课网学生的uid和对应的积分进行一对一关联；
数据去重：使用数组实现需要遍历，效率低，而Set集合本身就具有不能重复的特性；
需要数据的增删：使用数组实现增删操作需要遍历、移动数组中元素，如果操作频繁会导致效率降低。

Collection

java.util.Collection接口的实现可用于存储 Java 对象。

collection的常用方法：

迭代器

所有Collection的实现类，都实现了iterator方法，该方法返回一个Iterator接口类型的对象，用于
对于集合中的元素进行迭代遍历。

Iterator中有三个方法：

boolean hasNext(); // 判断是否还有下一个元素 E
next(); // 取出下一个元素
default void remove()；// 在原集合中返回刚刚

Comparable 接口

针对对象数组或者集合中的元素进行排序的时候，首先需要确定元素的比较逻辑，制定比较的
比较规则。
jdk中的Comparable接口，定义了对象间大小比较的方法，需要大小比较的类，可以实现该
接口。

public int compareTo(T o);

返回正数： this > o

返回负数 : this < o

返回 0 ： this == o

java泛型机制

泛型是java 1.5引入的新特性，泛型的本质是参数类型化。在类，接口和方法的定义过程中，所操作的数据类型被传入的参数指定。
java泛型机制广泛低应用于集合中，所有集合类型都带有泛型，在创建集合对象的时候，指定集合中元素的类型。
java编译器根据泛型的类型，对集合中元素进行类型检查，减少运行的时候错误。

Collection又可以分为三个子接口，分别是：

List：序列，必须按照顺序保存元素，因此它是有序的，允许重复；
Queue：队列，按照排队规则来确定对象产生的顺序，有序，允许重复；
Set：集，不能重复。

List

List 是元素有序并且可以重复的集合，称之为序列。序列可以精确地控制每个元素的插入位置或删除某个位置的元素。通过前面的学习，我们知道List是Collection的一个子接口，它有两个主要实现类，分别为ArrayList（动态数组）和LinkedList（链表）。

ArrayList & LinkedList

List接口的两个实现类分别用ArrayList , LinkedList
ArrayList用动态数组实现，适合于随机访问。
LinkedList用链表实现，适合于插入和删除。
ArrayList和LinkedList的方法一样，但是性能不同。

subList方法

List 的 subList 方法用于获取子 list

subList 获取的子 list 和原来的 list 占有相同的存储空间，对 subList 进行操作会影响原来的 list.

set

Set是元素无序并且不可以重复的集合，我们称之为集。Set是Collection的一个子接口，它的主要实现类有：HashSet、TreeSet、LinkedHashSet、EnumSet等。

Set 用于存储不重复的对象集合， set集合中存储的对象，不存在两个对象的equals相等。
HashSet 和 TreeSet是Set集合的两个常用实现类。
HashSet 用hash表实现了Set集合。

TreeSet 用排序二叉树实现了Set集合。
Set集合中的元素，不能和顺序的下标对应，无法从Set集合中获取除特定的元素。

Set和List的区别

1. Set 接口实例存储的是无序的，不重复的数据。List 接口实例存储的是有序的，可以重复的元素。
2. Set 检索效率低下，删除和插入效率高，插入和删除不会引起元素位置改变 <实现类有HashSet,TreeSet>。
3. List 和数组类似，可以动态增长，根据实际存储的数据的长度自动增长 List 的长度。查找元素效率高，插入删除效率低，因为会引起其他元素位置改变 <实现类有ArrayList,LinkedList,Vector> 。

Queue

队列是常用的数据结构，可以将队列堪称是特殊的线性表，队列只能从一端添加元素（offer）,另一端取出元素（poll）
队列遵循先进先出的原则（FIFO, first in first out）
Queue是jdk中的接口， LinkedList是Queue的实现类。

Dueue - 双端队列，模拟栈

Deque是Queue的子接口，被称为双端队列，即可以从队列的两端入队（offer）,出队（poll）,LinkedList实现了该接口。
将Deque限定为为只能从一段出队和入队，就可以模拟栈的数据结构，栈数据结构，入栈为push, 出栈为pop.
栈遵循先进后出的原则FILO（first int last out）

Map

java.util.Map接口的实现可用于表示“键”（key）和“值”（value）对象之间的映射。一个映射表示一组“键”对象，其中每一个“键”对象都映射到一个“值”对象。因此可以通过键来查找值。

小结

List集合是元素有序并且可以重复的集合；Set集合是元素无序并且不可以重复的集合；Map是以键值对（key-value）的形式存储的对象之间的映射，它们都支持泛型。

1、throw， throws , try...catch的区别

1)throw 就是抛出一个异常，并获取这个异常的引用，这个异常会被抛到外部的环境，由外部环境进行处理

2) throws并不是抛出一个实际的Exception而是一个异常声明，它声明这个方法可能会抛出一个异常，通常throws是写在参数列表的后面，这样就表明这个方法可能抛出的异常

3) try catch是直接处理，处理完成之后程序继续往下执行，throw则是将异常抛给它的上一级处理，程序便不往下执行了。

2、final , finally 的区别

1）final：用于修饰类，方法，变量。用final修饰的类，方法，变量都有不可变的特性。

1.final关键字用于基本数据类型前，就表明该变量变成了一个常量，在被定义后的赋值不能被修改

2.final关键字修饰的成员变量在定义是就应该赋值，并且只能赋值一次

3.final修饰的方法不能被重写，但是能被调用和重载

4.final修饰的类不能被继承

2）finally：用于异常处理机制

final用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。 finally是异常处理语句结构的一部分，表示总是执行。

八、异常

1.1异常类-Exception类

java 异常结构中定义有 Throwable, Exception 和 Error 是其派生的两个子类。其中 Exception 表示

由于网络故障，文件损坏，设备错误，用户输入非法等情况导致的异常，而 Error 表示 java 运行时环

境出现的错误，例如 jvm 内存资源耗尽。

异常出来就是当异常发生的时候妥善地终止程序，避免灾难性后果的发生，具体的操作通常包括；

通知：向用户通知异常的发生。

恢复：保存重要的数据，恢复文件，回滚事务等

退出：以更好的方式结束程序的运行

1.2try...catch

try{...} 语句包裹了一段代码，该段代码就是捕获异常的范围。

在执行 try 语句块的过程中，该段代码可能会抛出一种或多种异常， catch 语句块可以分别对不同的

异常做处理。

如果 try 语句块没有发生，那么所有的 catch 语句都被忽略，不被执行。

catch 语句块中是对异常处理的代码，不同的异常，可以多个不同的 catch 语句块。

当由多个 catch 语句的块的是，应该先捕获小类型的异常，或捕获大类型的异常。

1.3throw & throws

当程序发生异常，不能处理的时候，会抛出对应的异常。

可以通过 throw 语句，将异常抛出，那么被抛出的异常，可以让其他代码来捕获这个异常。如果需

要自行抛出异常，需要使用 “throw” 关键字，并且要创建出抛出的异常类的对象。

throw new XXException();

类中有很多方法，当在类中的方法中使用到了 throw 语句抛出了异常，那么在这些方法的声明过程

中，需要使用 throws 关键字，声明该方法抛出的异常。

public void add() thows XXExcedption{

// code

}

如果在方面声明的时候，使用 throws 抛出了异常，那么在调用方法的时候，就需要捕获异常，或者

继续抛出异常。

1.4finally

finally 语句为异常处理提供一个统一的出口，使得在控制流程转到其他程序其他部分之前，能够对

程序的状态做统一管理。

无论 try 语句块中是否有异常， finally 语句块的内容都会被执行。

通常在 finally 语句块中完成一些必须要执行的代码。比如：文件的关闭，数据库的关闭等。

1.5自定义异常

程序员可以自定义异常，解决自己程序中的一些特定内容：

public class GenderErrorException extends Exception{

// 重写异常类的方法

}

1.6RuntimeException

程序运行过程中，由某些特定操作引发的异常，被称为运行时异常。

1.7重写中异常的处理

如果父类的方法抛出了异常，那么子类重写父类的时候，异常可以如下处理：

a. 不处理异常（重写的时候，不抛出异常）

b. 可以只抛出部分异常

c. 可以抛出异常的子异常

d. 抛出其他运行时异常

但是不可以如下操作：

a. 重写的时候抛出父类没有抛的非运行时异常。

b. 重写的时候抛出父类没有抛的 Exception 。

九、Java 流(Stream)、文件(File)和IO

Java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。

Java.io 包中的流支持很多种格式，比如：基本类型、对象、本地化字符集等等。

一个流可以理解为一个数据的序列。输入流表示从一个源读取数据，输出流表示向一个目标写数据。

1.文件（File）

java.io.File用于表示文件(目录)，程序员可以通过File类在程序中操作硬盘上的文件或目录。
File类只用于表示文件(目录)的信息(大小，名称等)，不能对文件内容进行访问

2.1FileInputStream & FileOutputStream

节点流：从特定的地方读写的流，例如磁盘或一块内存区域。
FileInputStream ：输入流，操作的是字节，又叫字节流。
FileOutputStrean: 输出流，操作的是字节，又叫字节流。

2.2BufferedInputStream & BufferedOutputStream

使用节点流作为输入或输出。过滤流是使用一个已经存在的输入流或输出流进行创建的。
BufferedInputStream & BufferedOutputStream 是过滤流

2.3DataOutputStream & DataInputStream

DataOutputStream & DataInputStream是对流功能的扩展，可以更方便的读取int ,long ,char等类型的数据
DataOutputStream对基本的输出流功能进行扩展，提供了基本数据类型的输出方法
DataInputStream对基本的输入流功能的扩展，它提供了基本类型的输入方法

2.4InputStreamReader & OutputStreamWriter

提供字符的处理，一次处理一个字符(unicode)
字符的底层仍然是基本的字节流
InputStreamReader ：完成byte流解析为char流，按照编码解析。
OutputStreamWriter：提供char流到字节，按照编码处理。

2.5BufferReader & BufferWriter

BufferReader & BufferWriter更方便处理字符

对象序列化的原理

将Object转换为byte序列，就是序列化，反之将byte序列转换为Object就是反序列化。
对象序列化的目的，是为了将对象，以byte流的方式存储。
使用writeObject(Object)/readObject()进行序列化和反序列化

ObjectInputStream ois ;

ois . readObject ();

ObjectOutputStream oos ;

oos . writeObject ( obj );

Serializable接口

Serializable是序列化接口，对象必须实现序列化接口，才能进行序列化，否则抛出异常。
java的API中的类，大部分都实现了Serializable接口。

transient关键字

transient关键字修饰的成员变量，不会被序列化。
private transient Integer brId;

十、线程

进程，是指计算机中已运行的程序，它是一个动态执行的过程。假设我们电脑上同时运行了浏览器、QQ 以及代码编辑器三个软件，这三个软件之所以同时运行，就是进程所起的作用。

线程是操作系统能够进行运算调度的最小单位。大部分情况下，它被包含在进程之中，是进程中的实际运作单位。也就是说一个进程可以包含多个线程， 因此线程也被称为轻量级进程。

java程序支持多线程，并且java中的多线程处理较为简单。

一般操作系统都支持同时运行多个任务，一个任务通常就是一个程序，每个运行中的程序被称为进程， 当也给程序运行时候，内部可能包含多个顺序流执行，每个顺序执行流就是一个线程。

在 Java 中，创建线程有以下 3 种方式：

继承 Thread 类，重写 run() 方法，该方法代表线程要执行的任务；
实现 Runnable 接口，实现 run() 方法，该方法代表线程要执行的任务；
实现 Callable 接口，实现 call() 方法，call() 方法作为线程的执行体，具有返回值，并且可以对异常进行声明和抛出。

1.1继承线程

Thread类代表线程类型
任何线程对象都是Thread类(子类)的实例
Thread类是线程的模板（封装了复杂的线程开启等操作，封装了操作系统的差异性等）
只要重写run方法，就可以实现具体线程。
创建线程实例（即子类的对象）
通过start方法，启动线程，线程启动之后，会尽快执行run方法

1.2重写Runnable接口

创建一个类，实现Runnable接口，重写run 方法
以实现了Runnable接口的类的实例，作为创建Thread类的参数。

1.3Callable 和 Future 创建线程

创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。

1.4使用匿名内部类创建线程

1.5线程的生命周期及状态

java.lang.Thread.Starte 枚举类中定义了 6 种不同的线程状态：

NEW：新建状态，尚未启动的线程处于此状态；
RUNNABLE：可运行状态，Java 虚拟机中执行的线程处于此状态；
BLOCK：阻塞状态，等待监视器锁定而被阻塞的线程处于此状态；
WAITING：等待状态，无限期等待另一线程执行特定操作的线程处于此状态；
TIME_WAITING：定时等待状态，在指定等待时间内等待另一线程执行操作的线程处于此状态；
TERMINATED：结束状态，已退出的线程处于此状态。

Java Thread类

Java提供了Thread类来实现线程编程。 Thread类提供了在线程上创建和执行操作的构造函数和方法。 Thread类扩展了Object类并实现了Runnable接口。

Thread 主要方法：

序号	方法描述
1	public void start() 使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
2	public void run() 如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
3	public final void setName(String name) 改变线程名称，使之与参数 name 相同。
4	public final void setPriority(int priority) 更改线程的优先级。
5	public final void setDaemon(boolean on) 将该线程标记为守护线程或用户线程。
6	public final void join(long millisec) 等待该线程终止的时间最长为 millis 毫秒。
7	public void interrupt() 中断线程。
8	public final boolean isAlive() 测试线程是否处于活动状态。

Thread 类的静态方法：

序号	方法描述
1	public static void yield() 暂停当前正在执行的线程对象，并执行其他线程。
2	public static void sleep(long millisec) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
3	public static boolean holdsLock(Object x) 当且仅当当前线程在指定的对象上保持监视器锁时，才返回 true。
4	public static Thread currentThread() 返回对当前正在执行的线程对象的引用。
5	public static void dumpStack() 将当前线程的堆栈跟踪打印至标准错误流。