1.概述
异常：就是程序在运行时出现不正常的情况。
异常的由来：问题也是现实生活中的一个具体的事物，也可以通过Java的类的形式进行描述，并封装成对象。
其实就是Java对不正常情况进行描述后的对象体现。
对于问题的划分：两种 一种是严重的问题，一种是非严重的问题。
对于严重的问题，Java通过Error类来进行描述，对于Error一般不写针对性的代码进行处理。
对于非严重的问题，Java通过Exception类来进行描述，对于Exception可以使用针对性的处理方式来处理。
2.常见错误和异常
java.lang.NoClassDefFoundError 类没有找到错误
java.lang.ArrayIndexOutOfBoundsException 数组下标越界异常
java.lang.NullPointerException 空指针异常
java.lang.ArithmaticException 数学运算异常
实例：byte[] arr = new byte[1024*1024*600];抛出内存溢出异常，因为虚拟机本身有自己分配的内存空间
3.异常的处理
java提供了特有的语句进行处理。
try
{
需要被检测的代码;
}
catch(异常类 变量)
{
处理异常的代码;（处理方式）
}
finally
{
一定会执行的语句;
}
异常的执行流程：
细节：由于在执行d.div(4,0)这个方法时，抛出异常，因此直接跳转到catch语句块执行，System.out.println("x="+x);这句代码执行不到，因为catch语句捕捉到异常并处理了，因此System.out.println("over");语句可以执行到，只有当出现异常时才会执行catch代码块
4.异常信息处理的常用方法
5.异常处理的常用方式
方式一：
说明：在功能上通过throws关键字声明了该功能有可能会出现问题，当在主函数中使用该方法时必须处理该异常，否则报错，一般情况在主函数中都要处理调用方法的异常，如果不处理直接通过throws关键字继续上抛，那么最终由java虚拟机处理。
在函数上声明异常，便于提高安全性，让调用出进行处理，不处理编译失败！
补充：
每一份私下的努力都会有倍增的回报！
异常大纲：
1.6.1 java中异常的思想
1.6.2 异常体系结构
1.6.3 自定义异常
1.6.4 异常的分类
1.6.5 Throw与throws的区别
1.6.6异常的捕捉形式
1.6.7 代码快组合的特点
1.6.7 异常的处理原则
1.6.8 异常的注意事项
1.6.9 Finally
详细介绍开始吧：
异常：
异常的由来：是在运行时期发生的不正常情况。1.6.1 java中异常的思想
用类的形式对不正常情况进行了描述和封装对象，这种类成为异常类。
将正常流程代码和问题处理代码分离，提高了阅读性。不同的问题
用不同的类进行具体的描述，例如：角标越界，空指针等等。
1.6.2 异常体系结构
最终问题（不正常情况）就分成了两大类：
Throwable:
无论是error，还是异常，问题，问题发生就应该可以抛出，让调用者知道并处理。
该体系的特点就在于Throwable及其所有的子类都具有可抛性。
可抛弃到底指的是什么呢？怎么体现可抛性呢？
其实是通过两个关键字来体现的，throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性。
|----1,一般不可处理的。Error
特点：是由jvm抛出的严重性的问题。
这种问题发生一般不针对性处理，直接修改程序。
|----2,可以处理的。Exception
该体现的特点：
子类的后缀名都是用其父类名作为后缀，阅读性很强。
1.6.3 自定义异常
定义异常
让一个类称为异常类，必须要继承异常体系，因为只有异常体系子类才具备可抛性。
1.6.4 异常的分类
异常的分类：
编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
这样的问题都可以针对性的处理。
2,编译时不检测异常(运行时异常)：就是Exception中的和RuntimeException和其子类。
这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。
那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正。
所以自定义异常时，要么继承Exception，要么继承RuntimeException。
如果函数内发生了异常，就需要在函数上进行声明，否则编译失败。
你调用了发生异常的函数或声明异常的函数，你就必须要处理，不处理编译失败
示例代码：
对于角标是整数不存在，可以用角标越界表示，
对于负数为角标的情况，准备用负数角标异常来表示。
负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述。并封装成对象。
这种自定义的问题描述成为自定义异常。
注意：如果让一个类称为异常类，必须要继承异常体系，因为只有称为异常体系的子类才有资格具备可抛性。
才可以被两个关键字所操作，throws throw
class FuShuIndexException extends Exception
{
FuShuIndexException()
{}
FuShuIndexException(String msg)
{
super(msg);
}
}
class Demo
{
public int method(int[] arr,int index)//throws NullPointerException//FuShuIndexException
{
if(arr==null)
throw new NullPointerException("数组的引用不能为空！");
if(index>=arr.length)
{
throw new ArrayIndexOutOfBoundsException("数组的角标越界啦，哥们，你是不是疯了？："+index);
}
if(index<0)
{
throw new FuShuIndexException("角标变成负数啦！！");
}
return arr[index];
}
}
class ExceptionDemo3
{
public static void main(String[] args) //throws FuShuIndexException
{
int[] arr = new int[3];
Demo d = new Demo();
int num = d.method(null,-30);
System.out.println("num="+num);
System.out.println("over");
}
}
1.6.5 Throw与throws的区别
throws使用在函数上，throws使用在函数内
throws抛出的是异常类，可以抛出多个，用逗号隔开，而throw抛出的是异常对象throw可以用来结束函数。
1.6.6异常的捕捉形式
这是可以对异常进行针对性处理的方式。
具体格式是：
try
{
//需要被检测异常的代码
}
catch(异常类变量) //该变量用于接收发生的异常对象
{
//处理异常的代码
}
finally
{
//一定会被执行的代码。
}
函数上声明的是什么异常，我们就catch的是什么异常。
示例代码：
class FuShuIndexException extends Exception
{
FuShuIndexException(){}
FuShuIndexException(String msg)
{
super(msg);
}
}
class Demo
{
public int method(int[] arr,int index)//throws NullPointerException,FuShuIndexException
{
if(arr==null)
throw new NullPointerException("没有任何数组实体");
if(index<0)
throw new FuShuIndexException();
return arr[index];
}
}
class ExceptionDemo4
{
public static void main(String[] args)
{
int[] arr = new int[3];
Demo d = new Demo();
try
{
int num = d.method(null,-1);
System.out.println("num="+num);
}
catch(NullPointerException e)
{
System.out.println(e.toString());
}
catch (FuShuIndexException e)
{
System.out.println("message:"+e.getMessage());
System.out.println("string:"+e.toString());
e.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。
System.out.println("负数角标异常!!!!");
}
/*
catch(Exception e)//多catch父类的catch放在最下面。
{
}
*/
System.out.println("over");
}
}
当有多个catch出现时应注意的事项：
示例代码：
1.6.7 代码快组合的特点
try catch finally
try catch//不需要关闭资源
try finally//异常无法直接catch处理，但是资源需要关闭。
1.6.7 异常的处理原则
函数内容如果抛出需要检测的异常，那么函数上必须声明，或者在
函数内使用try catch捕捉，否则编译失败。
如果调用到了声明异常的函数，要么try catch 要么throws 。否则编译失败。
什么时候使用catch，什么时候throws？
功能内容可以解决，用catch。
解决不了，用throws告诉调用者，有调用者处理。
一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。内部有几个需要检测的异常，就抛出几个异常，抛出几个，就catch几个。多catch时，父类必须放在最下面。
1.6.8 异常的注意事项
子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
如 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。
注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try.
异常练习示例：
示例代码：
需求：张老师用电脑讲课。
public class ExceptionTest1 {
/**
* @param args
*/
public static void main(String[] args) {
Laoshi lao = new Laoshi("张孝祥");
try {
lao.prelect();
} catch (NoplayException e) {
System.out.println(e.toString());
System.out.println("换人");
}
}
}
class LanpingleExceptionextends Exception{
LanpingleException(String message){
super(message);
}
}
class MaoyanleExceptionextends Exception{
MaoyanleException(String message){
super(message);
}
}
class NoplayExceptionextends Exception{
NoplayException(String message){
super(message);
}
}
class NoteBook{
private int state =2;
public void run()throws LanpingleException, MaoyanleException{
if(state == 1)
throw new LanpingleException("电脑蓝屏啦");
if(state == 2)
throw new MaoyanleException("电脑冒烟啦");
System.out.println("电脑运行");
}
public void rest(){
state = 0;
System.out.println("电脑重启");
}
}
class Laoshi{
private String name;
private NoteBook compu;
Laoshi(String name){
this.name = name;
compu = new NoteBook();
}
public void prelect()throws NoplayException{
try {
compu.run();
System.out.println(name+"开始讲课");
} catch (LanpingleException e) {
System.out.println(e.toString());
compu.rest();
prelect();
} catch (MaoyanleException e) {
System.out.println(e.toString());
test();
throw new NoplayException("由于课时进度无法继续的原因："+e.getMessage());
}
}
public void test(){
System.out.println("大家练习");
}
}
1.6.9 Finally
通常用于关闭(释放)资源。
