day22_ 异常 throw throws try..catch.. finally

今日内容

  • 异常

异常:

 异常的根类是java. lang . Throwable,其下有两个子类分别是:java . lang .Error 和 java . lang. Exception.

 Error是错误,不可通过异常处理的错误,就好比人体的艾滋病,癌症等,只能是事先预防

 今天主要是说Exception(编译期异常):异常。是可以通过代码的方式进行修改纠正,然后可以继续进行下去。好比人的感冒等

  Exception的RuntimeException(运行期异常)包括常见的:

ArrayIndexOutOfBoundsException:  索引越界异常

其中有5个关键字:throw , throws , try   catch , finally

  throw:抛出异常

  编写程序的时候程序可能会出现问题,可以使用throw关键字在指定的方法中抛出指定的异常

  使用格式:

throw new XxxException("异常产生的原因");

  注意:

  1.throw关键字写在方法的内部。

  2.throw关键字后面必须是Exception或者Exception的子类对象

  3.throw关键字抛出指定的异常对象后。我们就必须去处理这个异常对

    throw关键字后面创建的是RuntimeException或者RuntimeException的子类对象,我们可以选择不处理,交给(打印异常对象,)

    throw关键字后面创建的是编译异常(写代码的时候就会出现的问题),我们就必须处理这个异常,要么是throws,要么使用try。。。catch

public static void main(String[] args) {
    int[] arr = null;
    int a =  get(arr, 2);
    System.out.println(a);//
}    
    public static int get(int[] arr,int index){
        if (arr==null) {
            //
            throw new NullPointerException("传递的数组值为null");
        }        
        return arr[index];
    }
}

  throws关键字

    异常处理的第一种方式:声明异常处理,将异常交给方法的调用者来处理

    当方法内部抛出了异常,我们必须处理这个异常对象,这个方法把异常对象抛给方法的调用者,调用者再网上抛,最终教给虚拟机,虚拟机中断处理

  格式:

    修饰符  返回值类型  方法名(参数列表)  throws  XxxException,ZzzException...{

      throw new XxxException("产生的原因");
      throw new ZzzException("产生的原因");
        ......
}

    注意:

    1.throws 关键字必须写在方法声明处。

    2.throws 关健字后面声明的异常必须是Exception或者是Exception的子类

    3.方法内部如果抛出了多个异常对象,那么throws后面也必须声明对应的多个异常,如果抛出的多个异常对象有父子类关系的时候,可以直接声明父类类型即可

    4.调用了一个声明抛出异常的方法(通过throw方法抛出),我们就必须处理这个异常声明,要么继续throws抛出,要么使用try...catch处理

 备注:异常到哪一个,就终止在哪。   

public static void main(String[] args) throws FileNotFoundException, TimeoutException {
        
    String pString ="C:\abc.txt" ;
     haha(pString);
    
    System.out.println( "keyi ");        
}    
public static void haha(String pString) throws FileNotFoundException, TimeoutException{
    if (!pString.endsWith("txt")) {
        throw new FileNotFoundException("不是txt");
    }
    if (!pString.startsWith("C:")) {
        throw new TimeoutException("不是C盘");
    }
    
}

Objects非空判断

  该类中提供了静态方法,null - save(空指针安全)或者null- tolerant(容忍空指针)。在他的源码中,对对象的null值进行了抛出异常的操作

public static <T> T  requireNonNull(T obj){
    if(obj == null)
      throw new NullPointerException();
     return obj;
}

捕获异常try...catch

自己处理异常

  如果异常出现的话,会立即终止程序。两种方法

  1.上述throws声明处理,危险

  2.方法中使用try...catch的语句块来处理异常

try .... catch的方式是捕获异常

  捕获异常的方式:可以对出现的异常指定方式捕获;

格式:

try{
    //编写的可能会出现异常的代码
    //.....
}catch(异常类型  c){
       //处理异常的逻辑代码
//一般在工作中,会把异常的信息记录到日志中
}

其中try:该语句块中可能出现异常的代码

catch:用来进行某种异常的捕获,实现对捕获到的异常进行处理

备注:try和catch都不能单独使用,一般建议连用

演示:

Thowable类中定义了一些常用的api方法

  public String getMessage()获取异常的描述信息,原因(提示给用户看的,提示错误原因);

  public String toString();获取异常的类型,异常的描述信息

  public void printStackTrace(): 打印异常的跟踪栈信息并输出到控制台中

这包含了异常的类型,原因,出现的位置。开发和调试阶段一般都适用

  Finally语句块

  finally: 有一些特殊代码无论异常是否发生,都需要执行,当程序发生异常时,会引发程序的跳跃性,finally语句块中的代码是一定会被执行到的。

  格式:

try{
//
}catch(异常类型  e){
     //...          
}
...
}finally{
//...
}

备注:中间的catch语句块可以不省略,finally不能单独使用,建议连用

注意事项:

1.finally不能单独使用,必须和try一起使用

2.finally语句块一般用于资源的释放,(资源回收),无论程序是否出现异常,最后都要加载finally语句块中的内容,都要释放资源

备注:

  如果finally语句块中有return语句,永远返回的是finally语句块中的结果值。

  当只要在try或者catch中调用退出JVM的相关方法,此时finally才不会被执行到,否则finally永远会执行

异常的注意事项

  程序中出现多个异常

  1.多个异常分别处理

  2. 多个异常一次捕获,多次处理

  3.多个异常一次捕获,一次处理

一般用的是一次捕获,多次处理,格式如下:

try{
//可能出现异常的代码  多个异常
}catch(异常A){//当try中出现A异常的时候,就用该catch来捕获
//处理异常的逻辑
}catch(异常B){//当try中出现B异常的时候,就用该catch来捕获
//处理异常的逻辑
}
....
...

要求catch多个异常不能相同,异常之间有父子关系,子类处理在上,父类在下。

  • 运行时异常被抛出可以不处理,即不捕获也不声明抛出
  • 如果finally中有return语句,那么永远返回finally语句块中的结果值
  • 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常
  • 父类方法如果没有抛出异常,子类重写该方法时,也不可能抛出。此时如果子类方法内产生了异常,只能捕获处理,不能声明抛出。

自定义异常

概述:

  出去官方提供的异常外,还要自定义的异常类。例如:年龄负数,成绩负数,登录异常等等

异常类定义:

  • 自定义一个编译期异常,自定义类继承于java.lang.Exception。
  • 自定义一个运行期异常类,自定义类继承与java.lang.RuntimeException。

 例子:

//自定义异常类步骤
//1.定义一个异常类  类继承系统给定的异常类
public class ExceptionDemo01 extends Exception {
    // 空参构造
    public ExceptionDemo01() {
    }
    // 全参 参数设置为传输的字符串
    public ExceptionDemo01(String a) {
        super(a);
    }
}


public class Application {
    // 成员静态变量设置
    public static String[] name = { "小孙", "小王", "小丽", "小张" };
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String names = sc.next();
        // 3.try...catch
        try {
            // 方法调用,有参数的话要传参数
            nemeDemo(names);
            System.out.println("名字可以,万里挑一");
            // ()里面是异常类名 e是给方法生成名字
        } catch (ExceptionDemo01 e) {
            // 调用输出方法三种
            e.printStackTrace();// 直接打印异常所有信息
            System.out.println(e.getMessage());// 显示内容及类型
            System.out.println(e.toString());// 只显示内容
        }
    }
    // 2.做一个方法遍历检查
    public static void nemeDemo(String uname) throws ExceptionDemo01 {
        // for遍历
        for (String string : name) {
            if (string.equals(uname)) {
                // 格式: throw+new +异常类名(参数传输字符串)
                throw new ExceptionDemo01("名字没了你妹的");
            }
        }
    }

}

  

原文地址:https://www.cnblogs.com/rxqq/p/14109707.html