黑马程序——异常总结（黑马我来了之八）

---------------------- android培训、java培训、期待与您交流！ ----------------------

异常
1、异常的体系

Throwable

|--Error

|--Exception
2、exception和error的子类都是以父类名作为后缀
3、异常：就是程序在运行时出现不正常情况
4、异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是java对不正常情况进行描述，后的对象体系那。
5、对于问题的划分：两种
(1)、一种是严重的问题，java通过error类进行描述
a、对于error，一般不编写针对性的代码对其进行处理
(2)、对于非严重的，java通过exception类进行描述
b、对于exception可以使用针对性的处理方式进行处理。

(3)、无论error或者exception都具有一些共性内容，比如：不正常情况的信息，引发原因等。
异常try-catch
1、异常的处理
try

{
需要被检测的代码
}catch()

{
处理异常的代码：（处理方式）
}finally

{
一定会执行的语句
}
2、例子

class ExceptionDemo{ 
int div(int a,int b){
return a/b; //产生了 ArithmeticException，并把问题封装成了一个对象
}
}
public class Demo{ 
public static void main(String[] args){ 
ExceptionDemo ed = new ExceptionDemo();
try{
int x = ed.div(4,0); //new ArithmeticException()
System.out.println("x="+x); //因为上边已经发生了异常，所以这一步不会再执行
}catch(Exception e){ //Exception e = ArithmeticException();
System.out.println("除零了");
System.out.println(e.toString());//异常名称：异常信息
System.out.println(e.getMessage());//by zero
System.out.println(e.printStackTrace());//异常名称，异常信息，异常出现的位置
//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。打印异常的堆栈的跟踪信息。
}
System.out.println("over");
}
}

3、对捕获到的异常进行常见方法操作。
(1)、String getMessage()：获取异常信息
(2)、toString():返回此 throwable 的简短描述

异常声明throws
1、在类的函数上声明 throws Exception，在对象在调用函数时，必须捕捉或者声明抛出
2、声明异常时，建议声明更具体的异常，这样处理可以更具体
3、对方声明几个异常，就对应有几个catch块
(1)、如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
4、建立在进行catch处理是，catch中一定要定义具体处理方式，不要简单定义一句，e.printStackTrace(),也不要简单的就书写出一条语句
5、

class ExceptionDemo{ 
int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException{ //在功能上通过 throws 的关键字声明了该功能有可能会出现问题,可以声明多个异常
int[] arr = new int[a];
System.out.println(arr[3]);//虽然有多个异常，但是当前面有异常时，该方法块内，异常后面的就不会运行
return a/b; 
}
}
public class Demo{ 
public static void main(String[] args){ 
ExceptionDemo ed = new ExceptionDemo();
try{
int x = ed.div(3,0); 
System.out.println("x="+x);
}catch(ArithmeticException e){
System.out.println("除零了");
}catch(ArrayIndexOutOfBoundsException e){
System.out.println("角标越界了");
}
System.out.println("over");
}
}

自定义异常 
1、因为项目中会出现特有的问题，而这些问题并未被java所表述并封装对象，所以对于这些特有的问题可以按照java的对问题的封装思想。将特有的问题，进行自定义的异常封装
2、当在函数内部出现了 throw 抛出异常对象，那么就必须要给对应的处理动作
(1)、要么在内部 try catch 处理，
(2)、要么在函数上声明让调用者处理
3、一般情况下，函数内出现异常，函数上需要声明
4、定义异常信息，因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句，那么就可以直接通过 getMessage 方法获取自定义的异常信息
5、自定义类必须是继承 Exception 类。
6、为什么要继承exception
(1)、异常体系有一个特点：因为异常类和异常对象都要被抛出，他们都具备可抛性
(2)、这个可抛性是 Throwable 这个体系中独有特点
(3)、只有这个体系中的类和对象才可以被 throws 和 throw 操作
7、例子 
*/
class FuShuException extends Exception{
private int value;
FuShuException(String msg,int value){
super(msg);//定义异常信息，因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句，那么就可以直接通过 getMessage 方法获取自定义的异常信息
this.value = value;
}
public int getValue(){
return value;
}
}
class ExceptionDemo{
int div(int a,int b) throws FuShuException{ //函数内出现异常，函数上需要声明
if(b<0){
throw new FuShuException("除数为负数了",b);
}
return a/b; 
}
}
public class Demo{
public static void main(String[] args){ 
ExceptionDemo ed = new ExceptionDemo();
int x = 0;
try{
x = ed.div(3,-1); 
}catch(FuShuException e){
System.out.println(e.toString());
System.out.println("该负数是："+e.getValue());
}
System.out.println("x="+x);
System.out.println("结束");
}
}

throw和throws的区别
1、throws 使用在函数上，throw 使用在函数内
2、throws 后面跟的异常类，可以跟多个，用逗号隔开，throw 后面跟的是异常对象。

RuntimeException
1、Exception中有一个特殊的子类异常， RuntimeException 运行异常
2、如果在函数内抛出异常，函数上可以不用声明，编译一样通过
3、如果在函数上声明了该异常，调用者可以不用进行处理。编译一样通过
4、之所以不用在函数上声明，是因为不需要让调用者处理。当该异常发生，希望程序停止，因为在运行时，出现了无法继续的运算情况，希望停止程序后，对代码进行修正。
5、自定义异常时，如果该异常的发生，无法再继续进行运算，就让自定义异常继承 RuntimeException
6、对于异常，分两种
(1)、编译时被检测的异常（如Exception）
(2)、编译时不被检测的异常（运行时异常，RuntimeException以及子类）

异常-finally

1、finall中存放的是一定会被执行的代码，通常用于关闭资源
异常-处理语句其他格式
1、 try catch
2、try catch finally
3、try finally
4、如果问题在内部被解决，比如内部catch（捕获），没有catch不行，则该方法不用声明异常
5、记住一点，catch是用于处理异常，如果没有catch就代表异常没有被处理，如果该异常是检测时异常，那么必须声明
异常-覆盖时的异常特点
1、如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类
2、如果父类方法抛出多个异常，那么子类再覆盖该方法时，只能抛出父类异常的子集
3、如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常
4、如果子类方发发生了异常，就必须要进行try处理，绝对不能抛
5、如果在子类的覆盖方法确实需要抛出非父类的异常或者该异常的子类，则必须在内部解决

异常-总结
1、异常：是对问题的描述，将问题进行对象的封装。
2、异常体系：
Throwable
|--Error
|--Exception
    |--RuntimeException
3、异常体系的特点：
(1)、异常体系中的所有类以及建立的对象都具备可抛性
(2)、也就是说可以被throw和throws关键字所操作
(3)、只有异常体系具备这个特点 
4、throw和throws的用法
(1)、throw定义在函数内，用于抛出异常对象。
(2)、throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开
5、当函数内中有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败
(1)、RuntiimeException除外，也就是说，函数内如果抛出的RuntimeException异常，函数上可以不用声明
6、如果函数声明了异常，调用者需要进行处理，处理方法可以throws 也可以 try
7、异常有两种
(1)、编译时异常
[1]、该异常在编译时，没有处理(没有抛出也没有try)，编译失败
(2)、运行是异常(编译时不检测)
[1]、在编译时，不需要处理，编译器不检查
[2]、该异常的发生，建议不处理，让程序停止，需要对代码进行修正
8、异常处理语句
(0)、System.exit(0); 系统退出，jvm结束
(1)、格式
try{需要要被检测的代码
}catch{处理异常的代码
}finally{一定会执行的代码
}
(2)、组合
(1)、try catch
(2)、try finally
(3)、try catch finally
(3)、注意 
(1)、注意：finally中定义的通常是 关闭资源代码，因为资源必须释放
(2)、finally只有一种情况不会执行，当执行到 System.exit(0);
9、自定义异常 定义类继承Exception或者RuntimeException
(1)、为了让该自定义类具备可抛性
(2)、让该类具备操作异常的共性方法
(3)、当要自定义异常的信息时，可以使用父类已经定义好的功能，异常信息传递给父类的构造函数。
class MyException extends Exception{
MyException(String message){
super(message);
}
}
(4)、
10、异常的好处
(1)、将问题进行封装。
(2)、将正常流程代码和问题处理代码相分离，方便于阅读。
11、异常的处理原则
(1)、处理方式有两种：try 或者 throws
(2)、调用到抛出异常的功能时，抛出几个，就处理几个，一个try对应多个catch
(3)、多个catch，父类的catch放到最下面
(4)、catch内，需要定义针对性的处理方式，不要简单的定义 printStackTrace ，输出语句，也不要不写
(5)、当捕获到的异常，本功能处理不了时，可以继续在catch中抛出
try{
throw new AException();
}catch(AException e){
}
12、如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转换后，再抛出和该功能相关的异常
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理，也可以将捕获的异常处理后，转换为新的异常
try{
throw new Aexceptihon();
}catch(Aexceptihon e){
//对Aexceptihon进行处理
throw new BException();
}
13、异常的注意事项
(1)、在子父类覆盖时
[1]、子类抛出的异常必须是父类的异常的子类或者子集
[2]、如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛出

---------------------- android培训、java培训、期待与您交流！ ----------------------