2020-11-11

JavaSE知识点总结（力推萌新学习！！！）
磨刀不误砍柴工，下面是我作为初学者，到学完Java基础的感悟。特分享给大家。
在B站官看动力节点视频，最后做出总结，为Java萌新推波助澜，更上一层楼！希望大家在编程的道路上越走越远，愈战愈强！！！。遇到困难，善于分析；解决问题，勤于总结。耐心和坚持是我们非常关键的，大家分享，携手解决遇到的困难，每个人都会得到极大的进步。加油！！！
知识点的最后部分，没有过多的讲解，不是我懒了，而是不想以其昏昏，使其昭昭，把好的学习环境，学习氛围破坏了。最后的时候，希望大家都有一份属于自己的总结。当自己学习其他的内容时，把原来的忘记，温故而知新。所以有一份自己的知识总结，不失为明智之举。在学习我的总结的时候，更多的是希望大家参照我的学习规划来，框架摆在那儿，而内容需要自己去补充。觉得一个知识点需要动手实践多少次，可以灵活运用。编程，是靠实践积累起来的。只看而不屑于做练习，敲代码的人，请止步于此。
强制交易如果大家学到，觉得有帮助的话，请大家要么分享自己的知识总结，要么转发这篇文章，为后面的萌新提供一丝丝便利。另外如果文章的知识点哪里不对，或者有疑义，请大家不吝赐教，发表在评论区，或者留言给我，我及时修改以免更多人被误导。衷心感谢！！！

				在此，也动力节点的免费分享学习资料由衷的感谢。
学习视频（万分钟，学到就是赚到！）(https://www.bilibili.com/video/BV1Rx411876f)

1
2
1.第一章：Java开发环境的搭建
【1】软件开发介绍
·软件开发
软件：一系列按照特定顺序组织的计算机数据和指令的集合，有系统软件和应用软件之分。
系统软件----操作系统
·人机交互方式
图形化界面（GUI）：简单直观、使用者易接受。
命令行方式（CLI）：需要有一个控制台，输入特定的指令,需要记住指令，较为麻烦。 DOS
·常用的DOS命令
》dir: 列出当前目录的文件以及文件夹
》md: 创建目录
》rd: 删除目录
》cd: 进入指定目录
》cd…: 退回到上一级目录
》cd: 退回到根目录
》del: 删除文件
》exit: 退出dos命令行
【2】计算机编程语言介绍
计算机语言：人与计算机交流的方式。
C C++ Java PHP Kotlin Python Scala等
机器语言 ：指令以二进制代码形式存在。
汇编语言：使用助记符表示一条机器指令。
高级语言：面向过程、面向对象
【3】Java语言
SUN公司1995年推出的一门高级编程语言。
09年Oracle收购。
Java SE 标准版 桌面级应用
Java EE 企业版 企业级应用
Java ME 小型版 移动终端上
Java Card

Java之父 James Gosling
1
【4】运行机制及运行过程
Java语言特点：
1、面向对象
2、健壮性
3、跨平台性
通过Java语言编写的代码可以在任何操作系统上运行

核心机制–垃圾回收
垃圾回收在Java程序运行过程中自动进行，程序员无法精确控制和干预
1
2
【5】Java的环境搭建
JDK(Java Development Kit Java开发工具包)
JRE(Java Runtime Environment Java运行环境)
JDK =JRE+开发工具集（例如javac编译工具等）
JRE=JVM+JavaSE标准类库

安装路径：
不能包含空格和汉字，保留版本号

环境变量：配置路径 系统变量：JDK的bin目录放到path路径下
1、（多个版本JDK）环境变量配置的哪个JDK就用哪个JDK
2、（想配置到用户变量 ）新建一个path
3、将新建的path上移到最上面
1
2
3
4
5
6
7
【6】EditPlus
【7】将写好的代码以 .java 的文件类型保存
cmd Javac 编译 之后 Java 运行
【8】常用的开发工具

2.第二章：Java基础语法
【1】关键字和保留字
·关键字 【图】
·保留字：现有版本尚未使用，以后可能会使用
自己命名时，避开
goto、const
【2】标识符（Identifier）
·标识符：
Java对各种变量、方法和类等要素命名时使用的字符序列
称为标识符。
·技巧：凡是可以自己起名的地方都叫标识符。
·定义合法的标识符规则：
》由26个英文字母大小写，0-9，$或_组成
》数字不可以开头
》不可以使用关键字和保留字、但能包含关键字和保留字。
》Java中严格区分大小写，长度无限制
》标识符不能包含空格。
·Java中的名称命名规范
》包名：多单词组成时所有字母都小写 xxxyyyzzz
》类名、接口名：多单词组成时，所有单词的首字母都大写：XxxYyyZzz
》变量名、方法名：多单词组成时，第一个首字母小写，后边的首字母大写： xxxYyyZzz
》常量名：所有字母都大写、多单词时每个单词用下划线连接 :XXX_YYY_ZZZ
【3】变量
变量怎么定义
变量怎么赋值
变量的作用域
变量的分类
》基本数据类型
12488412 byte short int long float double boolean char
整型 ：byte 【1】、short 【2】 、int 【4】、long【8】
浮点型：float 【4】、double【8】
字符型：char 【2】
布尔型：boolean【1】
byte :-128~127
long型变量 以L或l结尾，不加的时候认为是int型
float 定义的变量需要加f
字符编码方式（理解字符编码）:DBK,UTF-8,ASCLL ISO-8859-1…
》引用数据类型
类(class)
接口(interface)
数组(array)
》基本数据类型转换
·自动类型提升(容量大小区分)
byte、char、 short -->int long float double
byte char short 运算结果是int
·强制类型转换
1、可能导致精度丢失
2、需要使用强转符
》基本数据类型与String转换
String不是基本数据类型，是引用数据类型
基本数据类型与String + ：连接运算。

int	Integer.parseInt(str)	
double Double.parseDouble(str)

》进制与进制间转换
二进制(binayr) 以0b或者0B开头
八进制(decimal) 以数字0开头表示
十进制 (octal)
十六进制(hex) 0-9以及A-F 以0x或者0X开头
1
2
3
4
5
6
7
1、标识符的命名规则有哪些？
2、标识符的命名规范有哪些？
3、Java变量按照数据类型怎么划分？并指出Java的基本数据类型有哪8种？
，并指出各自占用的空间大小。
short byte int long float double boolen char
2 1 4 8 4 8 1 2
4、说明基本数据类型变量之间自动类型提升的运算规则。
5、说明基本数据类型变量之间强制类型转换的使用规则和强转可能出现的问题。
1、float 定义变量
2、long 定义变量

【4】运算符
·算术运算符
·+ - * / %
·++(a=2;b=++a; a=3;b=3) ++(a=2;b=a++; a=3;b=2)
·–(a=2;b=–a; a=1;b=1) --(a=2;b=a–;a=1;b=2)
·+(“He”+“llo”) ;“Hello”)
·赋值运算符
· = += -= *= /= %=
·比较运算符（关系运算符）
·== != < > <= >= instanceof(检查是否是类的对象 “Hello” instanceof String 结果 true)
·逻辑运算符
&–逻辑与 |–逻辑或 !–逻辑非
&&–短路与 ||–短路或 ^–逻辑异或

逻辑与：第一个判断合格不合格 后边的代码都要进行判断
短路与：第一个判断不合格 后边的代码不在执行
逻辑异或：判断两个是否是一样的 一样为假 不一样为真
a b a&b a&&b a|b a||b !a a^b
1 1 1 1 1 1 0 0
1 0 0 0 1 1 0 1
0 1 0 0 1 1 1 1
0 0 0 0 0 0 1 0
·位运算符（系统源码会用到，实际开发用到的少）
<< 左移 3<<2=12–>322=12(在一定范围内)

右移 3>>1=1–>3/2=1（在一定范围内）

无符号右移 3>>>1=1–>3/2=1
& 与运算 6&3=2
| 或运算 6|3=7
^ 异或运算 6^3=5
~ 取反运算 ~6=-7
左移割去多出来的部分、右移看符号
无符号右移空缺位都用00补
面试题：最高效的方式计算 2*8 2<<3 8<<1
·三元运算符
（条件表达式）？表达式1：表达式2

运算符优先级 想要先用的加括号
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
【5】流程控制
顺序结构
分支结构
循环结构

控制语句
if
switch
循环语句
for
while
do while
转向语句
break
continue
return
1
2
3
4
5
6
7
8
9
10
11
【方法】（函数）

• 方法怎么定义
• 方法怎么调用
• 对方法返回值的理解
• 一个方法怎么返回值的
• 一个方法执行结束之后返回值怎么接收
• 方法的重载overload
  ·方法递归（递归算法）

3.第三章：面向对象

·面向对象怎么理解？
·类和对象
- 什么是类
- 什么是对象
·类怎么定义
·对象怎么创建
·属性怎么访问
·方法怎么访问
·理解JVM的内存管理
·new出来的对象存储在哪里

·空指针异常
·【封装】：属性私有化，对外提供公开的setter和getter放法。
·构造方法：conatructor
·【this关键字】
1、this是个关键字，翻译成：这个
2、this是一个引用，this是一个变量，this变量保存了内存地址指向了自身，存储在堆内存Java对象内部。
3、每个Java对象都有自身对应的this
4、this可以出现在实例方法当中(this代表当前对象)。实例方法（不带static）
5、多数情况下this可以省略不写
6、this不能使用在带有static的方法中
7、静态方法==>静态变量
8、main方法中没有this
实例变量、实例方法的引用都需要对象。
修饰符列表上有static
采用“类名.“的方式访问，显然这个方法在执行的时候不需要对象的参加。
static的方法调用不需要对象，直接使用类名，所以执行过程中没有当前对象，所以不能使用this
·【static关键字】
1、static关键字可以修饰成员变量和成员方法
- 特点：
被static修饰的成员变量会变成静态变量，静态变量不单单仅仅只是属于某一个对象的，
而是属于类的，所以静态变量会被该类的所有对象共享，也就是说所有该类的对象使用的是同一份数据。
2、实例方法和静态方法的访问
静态方法只能访问静态成员，
实例方法可以访问静态和实例成员。
之所以不允许静态方法访问实例成员变量，
是因为实例成员变量是属于某个对象的，
而静态方法在执行时，并不一定存在对象。
同样，因为实例方法可以访问实例成员变量，
如果允许静态方法调用实例方法，将间接地允许它使用实例成员变量，
所以它也不能调用实例方法。基于同样的道理，静态方法中也不能使用关键字this。
3、static代码块（类构造的时候执行，多个代码块时，按照顺序依次执行）
static关键字还有一个比较关键的作用就是
用来形成静态代码块以优化程序性能。
static块可以置于类中的任何地方，
类中可以有多个static块。
在类初次被加载的时候，
会按照static块的顺序来执行每个static块，
并且只会执行一次。
（JDBC class.format()处有用到静态代码块）
4、Java中规定：static不允许修饰局部变量。
·【super关键字】
1、用法：

• super可以用来引用直接父类的实例变量。
• super可以用来调用直接父类方法。
• super()可以用于调用直接父类构造函数
  2、注意：
  如果我们没有显式调用super来初始化父类的话，
  那么Java会隐式的调用super();
  来调用父类无参构造函数并把它放在构造函数的第一行
  ·【final】
  1、final 修饰类，表示这个类不能被继承
  final 类中的所有成员方法都会被隐式的指定为final方法
  （在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。）
  2、final修饰方法
  “使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。
  在最近的Java版本中，不需要使用final方法进行这些优化了。“
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  因此，如果只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。
  （　注：类的private方法会隐式地被指定为final方法。）
  3、修饰变量
  修饰变量是final用的最多的地方
  对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。
  public static void main(String[] args) {
  final int i= 1;
  // i =20;
  //java: 无法为最终变量i分配值
  final Object obj =new Object();
  obj =new Object();
  //java: 无法为最终变量obj分配值
  }

·【继承】
·方法的覆盖
1、什么时候进行方法重写？
如果父类中的方法已经无法满足当前子类的业务需求，需要将父类中的方法进行重新写一遍。就是要改变父类的行为。
注意如果重写父类中的方法之后，子类对象调用的一定是重写之后的方法。
2、发生方法覆盖的条件
- 发生在具有继承关系的两个类之间
- 必须具有相同的方法名，相同的返回值类型，相同的参数列表
- 重写的方法不能比被重写的方法拥有更低的访问权限
- 重写的方法不能比被重写的方法抛出更宽泛的异常
- 私有的方法不能被覆盖
- 构造方法无法被覆盖，因为构造方法无法被继承
- 静态方法不存在覆盖
- 覆盖指的是成员方法，和成员变量无关。
继承最基本的作用是：代码重用。继承最重要的作用：方法可以重写。
【方法重载】
- 方法名称相同
- 方法参数类型、个数、顺序至少有一个不同
- 方法的返回值类型可以不同
- 方法的修饰符可以不同
- 方法重载只能出现同一个类中

·【多态】：多态的基础语法+多态的作用（OCP开闭原则）
1、多态使用的好处：
- 消除了类之间的耦合关系
- 大大提高了程序的简洁性和可拓展性
2、子类对象的多态性，并不适用于属性
3、OCP开闭原则是指一个软件实体如类、模板和函数应该对扩展开放，对修改关闭。
强调的是用抽象构建框架，用实现扩展细节。
开闭原则是面向对象设计中最基础的设计原则。它指导我们应该如何建立稳定灵活的系统。
例如：我们版本更新，尽可能不修改源代码，但是可以增加新功能。
·【抽象类】
1、抽象类是指在普通类的结构里面增加抽象方法的组成部分
2、抽象方法：普通方法上面会有{}，这个表示方法体，有方法体的方法一定可以被对象直接调用，而抽象方法是指没有方法体的方法，
同时抽象方法还必须使用关键字abstract做修饰。
而拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。
3、抽象方法的使用原则如下：
- 抽象方法必须为public 或者protected（因为如果为private，则不能被子类继承，子类边无法实现该方法），缺省情况下默认为public
- 抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理
- 抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类
- 子类（如果不是抽象类）则必须覆盖抽象类中的所有抽象方法。（如果子类没有实现父类的抽象方法，则必须将子类也定义为abstract类）
4、抽象类的使用限制
（1）抽象类中有构造方法么？
由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。
并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。
（2）抽象类可以用final声明么？
不能，因为抽象类必须有子类，而final定义的类不能有子类；
（3）抽象类能否使用static声明？
外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。
·【接口】
- 接口的定义：接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
- 接口的特点：
1、Java接口中的成员变量默认都是public 、static、final类型的（都可以省略），必须被显示初始化，即接口中的成员变量为常量。
2、Java接口的方法默认都是public、abstract类型的（都可省略），没有方法体，不能被实例化
3、Java接口中的方法只能包含public static final 类型的成员变量和public abstract 类型的成员方法
4、接口中没有构造方法，不能被实例化
5、一个接口不能实现（implement）另一个接口，但是它可以继承多个其他接口
6、Java接口必须通过类来实现它的抽象方法
7、当类实现某个Java接口时，它必须实现接口中的所有抽象方法，否则这个类必须声明为抽象类
8、不允许创建接口的实例，但允许定义接口类型的引用变量，该引用变量引用实现了这个接口的类的实例
9、一个类只能继承一个直接的父类，但可以实现多个接口，间接的实现了多继承。
- 接口的用法
两个及以上的类拥有相同的方法，但是实现功能不一样，就可以定义一个接口，将这个方法提炼出来，在需要使用该方法的类中去实现，就免去了定义系统方法的麻烦。
·例如：人会吃饭，睡觉
人有三个身份 学生、 教师 、校领导
吃的不一样，住的不一样
但是都会吃、住。
此时定义一个接口
interface Peron{
void eat();
void sleep();
}
·【Object类中的常用方法】
equals hashCode toString finalize clone…
·【内部类】：重点掌握匿名内部类。

内部类：
	1.什么是内部类?
		内部类：在类的内部又定义了一个新的类。被称为内部类。

	2.内部类的分类
		静态内部类：类似于静态变量
		实例内部类：类似于实例变量
		局部内部类：类似于局部变量
	3.匿名内部类
		
		new 接口{实现方法}

·【向上转型 ||向下转型】
- 向上转型
通过子类对象(小范围)实例化父类对象(大范围),这种属于自动转换
向上转型时,父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的.
public class A{
public void fun(){
sout(“A”);
}
}
public class B extends B{
public void fun(){
sout(“B”);
}
}
main(){
A a= new B(); //向上转型 自动的
a.fun();
}
输出： B

- 向下转型
	通过父类对象(大范围)实例化子类对象(小范围),这种属于强制转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
public class C extends A{
public void fun() {
System.out.println(“C”);
}

public void funC(){
System.out.println(“C的方法啊”);
}
1
2
3
}

public class ABCtest {

public static void func(A a){
a.fun();
if( a instanceof B){
B b =new B();
b.funB();
}
else if(a instanceof C){
C c= new C();
c.funC();
}
}
public static void main(String[] args) {
func(new A());
func(new B());
func(new C());
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
}
结果：A
B
B的方法
C
C的方法啊

【JVM内存结构——堆、栈、方法区】

方法区；类加载器classloader,将硬盘上的xxx.class字节码文件装载到JVM的时候，会将字节码文件存放到方法区当中，也就是说方法区中存储的是代码片段。
（因为类需要加载，所以方法区当中最先有数据。）
栈内存：在方法被调用的时候，该方法需要的内存空间在栈中分配。
方法只有在调用的时候才会在栈中分配空间，并且调用的时候就是压栈。
方法执行结束之后，该方法所需要的空间就会释放，此时发生弹栈动作。
（给main方法分配空间）
1
2
3
4
5
6
一、定义

1、堆：FIFO队列优先，先进先出。jvm只有一个堆区被所有线程所共享！堆存放在二级缓存中，调用对象的速度相对慢一些，生命周期由虚拟机的垃圾回收机制定。

2、栈：FILO先进后出，暂存数据的地方。每个线程都包含一个栈区！栈存放在一级缓存中，存取速度较快，“栈是限定仅在表头进行插入和删除操作的线性表”。

3、方法区：用来存放方法和static变量。

二、存储的数据类型

1、堆用来存储new出来的对象和数组

2、栈用来存储基本类型变量和对象的引用变量的地址

3、方法区存储方法和static变量

三、优缺点

1、堆的优点-可以动态的分配内存大小，生命周期不确定。缺点-速度略慢

2、栈的优点-速度快，缺点-存在栈中的数据大小和生命周期必须是明确的，缺少灵活性。

4.第四章：数组
数组的内存解析

栈 堆 方法区
局部变量 new出来的结构 常量池
（对象、数组） 静态域

1、写出一维数组初始化的两种方式。
int[] arr=new int[5];//动态初始化
int[] arr=new int[]{};//静态初始化
2、写出二维数组初始化的两种方式。
int[][] arr=new int[len][len];//动态初始化1
int[][] arr=new int[len][];//动态初始化2
int[][] arr=new int[][]{ {},{}};//静态初始化
3、如何遍历如下的二维数组
int[][] arr=new int[][]{ {1,2,3},{6,7,8}};

for(int i=0;i for(int j=0;j System.out.print(arr[i][j]);
}
System.out.print("\n");
}
1
2
3
4
5
6
4、不同类型的一维数组元素的默认初始化值各是多少?
整型：0
浮点型：0.0
char :0
boolean:false
引用类型：null

5、一维数组的内存解析。

*数组一旦初始化，其长度就是确定的，不能更改。

【Arrays工具类的使用】
查看帮助文档。

常用方法
/*

• boolean equals(int[] a,int[] b) 判断两个数组是否相等
• String toString(int[] a) 输出数组的信息
• void fill(int[]a ,int val) 将指定值填充到数组之中
• void sort(int[] a) 对数组进行排序
• int binarySearch(int[] a,int key) 对排序后的数组进行二分检索指定的值

常见异常
/*
*数组角标越界异常：ArrayIndexOutOfBoundsException
*空指针异常：NullPointerException
**/
【String[] args】
当你使用命令行bai的形du式运行.class文件时,向你的类传递参数zhi.
C:>java YourClassName 参数1 [参数2 参数3 …]参数之间用一个空格bai作为间隔符.
String[] args 这个字符串数组是保存运行main函数时输入的参数的
，例如main函数所在的类名为test
那么你在cmd运行 java test a b c 时，
args[0] = a ,args[1]=b, args[2]=c
你就可以在你的程序中调用你输入的这些变量了。

【数组的扩容】
① int[] arr2=new int[arr1.length*2] //新数组长度

for(int i=0;i

② int[] arr2=java.util.Arrays.copyOf(原数组名，新数组长度);

③ int[] arr2=new int[arr1.length*2]
System.arraycopy(原数组名，起始下标，新数组名，起始下标，复制长度);
（本质就是用一个新的容量大的数组拷贝原数组的值）

1、使用冒泡排序，实现如下的数组从小到大排序
int[] arr=new int[]{34,5,22,-98,6,-76,0,-3};
2、如何反转上面的数组，请代码实现
3、复制上述数组，得到一个新的数组
4、使用线性查找，从上述数组中查找22是否存在，存在返回所在位置
的索引，不存在，输出提示信息
5、数组中常见的异常有哪些？请举例说明。

5.第五章 异常
·异常怎么理解
程序执行过程中出现了不正常情况，这种不正常情况叫做，异常。
java语言是很完善的语言，提供了异常的处理方式，一下程序执行过程中出现了不正常的情况，
Java把该异常信息打印输出在控制台，供程序员参考，程序员看到异常信息在之后，可以对
程序进行参数修改，让程序更加的健壮。

• 异常信息是JVM打印的。
  ·异常在Java中有什么用？
• 给程序员提示程序错误信息，一边修改。
• 增强健壮性
  ·异常在Java中以什么形式存在？
• 异常以类和对象的形式存在
  public static void main(String[] args) {
  NullPointerException n =new NullPointerException(“空指针异常”);
  System.out.println(n);
  //java.lang.NullPointerException: 空指针异常
  }
  ·异常的继承结构图
  Throwable（父类）
  ERROR（虚拟机错误、内存溢出、线程死锁）　 Exception（RuntimeException、IO异常、SQL异常）
  RuntimeException（空指针异常NullPointerException、
  数组下标越界异常 ArrayIndexOutOfBoundsException、
  算数异常ArithmeticException、
  类型转换异常ClassCastException）
  ·什么是编译时异常
  是RuntimeException以外的异常，
  类型上都属于Exception类及其子类。
  从程序语法角度讲是必须进行处理的异常，
  如果不处理，程序就不能编译通过。
  如IOException、SQLException等以及用户自定义的Exception异常，
  一般情况下不自定义检查异常。
  ·什么是运行时异常
  都是RuntimeException类及其子类异常，
  如NullPointerException(空指针异常)、
  IndexOutOfBoundsException(下标越界异常)等，
  这些异常是不检查异常，程序中可以选择捕获处理，
  也可以不处理。这些异常一般是由程序逻辑错误引起的，
  程序应该从逻辑角度尽可能避免这类异常的发生。
  运行时异常的特点是Java编译器不会检查它，也就是说，
  当程序中可能出现这类异常，即使没有用try-catch语句捕获它，
  也没有用throws子句声明抛出它，也会编译通过。
  ·ERROR　（错误）是程序无法处理的错误。表示代码运行时JVM出现问题。如JVM运行错误、类定义错误。