异常处理笔记

一、异常的概述

1.1程序中的异常

异常的定义： 异常指的是在程序的运行过程中发生的不正常的事件，它会中断正在运行的程序，简单的来说就是程序出现了不正常的情况。异常的本身就是Java当中对可能出现的问题进行描述的一种对象体现。

常见的异常：

1.除数不能为0(ArithmeticException)
2.空指针异常(NulPointException)
3.数组下标越界(ArrayIndexOutOfBoundsException)
4.类型转换异常(ClassCastException)

1.2异常的分类

1.编译异常【Exception】：程序在编译过程中发现的异常，受检异常
2.运行时异常【RuntimeException】:又称为非受检异常,
3.错误【Error】:有]ava虚拟机生成并抛出的异常，程序对其不做处理

二、异常的处理

2.1自己异常处理

通过try-catch 语句块来处理

2.1.1单个异常处理

语法规则

try{  
//放置程序可能出现的问题    
}catch(异常类型 异常名称){
//放置处理异常的代码
}finally{
//释放资源
}

catch中声明的异常类型应该和实际抛出的异常类型要么相同要么有继承关系才能捕获到。

2.1.2多个异常处理

try块中有多行代码，都有可能出现异常信息，程序执行的时候是从上往下执行的，当碰到异常情况的时候就会跳出try块，从而try块中剩余的代码就不会执行了

package com.异常处理;

public class Exception {
    public static void main(String[] args) {
        System.out.println("第一段代码");
        int i =10;
        String str = null;
        int[] arr=new int[3];
        arr[10]=100;
        try {
            System.out.println(i/0);
            System.out.println(str.length());
            arr[10]=100;
        }
        catch (ArithmeticException e) {
            System.out.println("除数为零");
        }
        catch (NullPointerException e) {
            System.out.println("空指针异常");
        }
        catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界异常");
        }
        catch (java.lang.Exception e)
        {
                e.printStackTrace();
        }
        System.out.println("第二段代码");
    }
}

2.2异常抛出

通过throws关键字将异常抛出

throws作用: 在定义一个方法的时候可以使用throws关键字声明，使用throws关键字声明的方法表示此方法不处理异常，而交给方法的
调用者进行处理

package com.异常处理;

public class Exception1 {
    public static void main(String[] args) {
       try {
           cacl();
       }catch (java.lang.Exception e)
       {
           e.printStackTrace();
       }
        System.out.println("******");
    }

    /**
     *
     * @return
     * @throws ArithmeticException ，谁调用本方法，本方法就可能抛出异常
     */
    public static int cacl() throws ArithmeticException {
        int a=10;
        int b=0;
        int result=a/b;
        return result;
    }
}

throws使用格式

[修饰符]返回值类型 方法名(参数列表)[throws 异常类1,异常类2....]{
}

注意:

• 1.如果一个方法声明的是编译时异常，则在调用这个方法之处必须处置这个异常(谁调用谁处理)
• 2.重写一个方法的时候，它所声明的异常范围不能被扩大

三、throw关键字

面试题：介绍一下throw throws和Throwable的区别

throw和throws的区别

• 1.throws用在方法名后面，跟的是异常类名，throw是用在方法体中，跟的异常对象
• 2.throws可以跟多个异常类名，用逗号隔开，throw只能抛出一个异常对象
• 3.throws表示抛出异常，由该方法的调用者来处理，throw表示抛出异常，由方法体内的语句处理
• 4.throws表示出现异常的一种可能性，并不一定发生这些异常，throw则是抛出了具体的异常，真实产生了一个Exception对象

package com.异常处理;

import java.lang.Exception;
import java.text.ParseException;

public class Exception2 {
    public static void main(String[] args) {
       try {
           cacl();
       }catch (java.lang.Exception e)
       {
           e.printStackTrace();
       }
        System.out.println("******");

        try {
            show();
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     *
     * @return
     * @throws ArithmeticException ，谁调用本方法，本方法就可能抛出异常
     */
    public static int cacl() throws ArithmeticException {
        int a=10;
        int b=0;
        if(b==0)
        {
            throw new ArithmeticException("除数为0，不能运算..");
        }
        int result=a/b;
        return result;
    }
    static void show() throws ParseException {
        int a=10;
        if(a==10){
            throw new ParseException("解析出错",1);
        }
    }
}

4.Finally关键字

语法格式

try{  
//放置程序可能出现的问题    
}catch(异常类型 异常名称){
//放置处理异常的代码
}finally{
//释放资源
}

finally修饰的代码一定会执行，除非在执行到finally之前程序异常退出或者调用了系统的退出方法

package com.异常处理;

import java.lang.Exception;
import java.text.ParseException;

public class Exception3 {
    /**
     * finally关键字
     * @param args
     */
    public static void main(String[] args){
        int a=10;
        int b=0;
       try {
//           if(a==10)
//           {
//               return;
//           }
           //System.exit(1);
           System.out.println(a / b);
       }
       catch (Exception e){
           System.out.println("除数不为零");
       }finally {//只有执行了try块中的代码，finally就会执行,不执行System.exit
           System.out.println("finally.....");
       }
        System.out.println("******");
    }
}

经典面试题

package com.异常处理;


/*
finally碰到return
finally一定会执行
执行顺序?
在try语句中，在执行return语句时，要返回的结果已经准备好了，就在此时，程序转到finally执行了。
在转去之前，try中先把要返回的结果存放到不同于x的局部变量中去，执行完finally之后，在从中取出返回结果,
因此，即使finally中对变量x进行了改变，但是不会影响返回结果。它应该使用栈保存返回值。
 */
public class Exception4 {

    public static void main(String[] args) {

        System.out.println(test());
    }
    public static int test() {
        int x=1;
        try{
            x++;
            return x;//2
        }finally{
            //finally中改变不了返回结果
            ++x;

            System.out.println(x);//3
        }
    }
}

输出结果:
3
2

面试题2：final，fianlly，finalize三者区别

• final 修饰的类能被继承 修饰的方法不能被重写 修饰的变量变常量
• finally 是try catch语句中的一部分，表示要最终执行的代码，常用来做资源的释放
• finalize: Object中的方法，在垃圾回收的时候会用到的方法

五、自定义异常

java中的异常都是Throwable或者Exception或者RuntimeException的子类，那么我们要创建一个自定义的异常，其实就是创建其对应的子类。
案例：编写一个分数必须在0~100之间的异常，并且使用这个异常

package com.异常处理;

public class Exception5 {
   /**
    * 编写一个分数必须在0~100之间的异常，并且使用这个异常
    */
   public static void main(String[] args) {

       try {
           System.out.println(getScore());
       } catch (ScoreException e) {
           e.printStackTrace();
       }
       System.out.println("******");
   }
   public static double getScore() throws ScoreException {
       double score = 999;
       if(score <0||score >100){
           //说明分数有问题
           throw new ScoreException("分数不合法");
       }
       return score;
   }
}

/**
* 自定义异常
*/
class ScoreException extends java.lang.Exception {

   public ScoreException() {

   }
   public ScoreException(String message) {
       super(message);
   }
}