java异常

异常处理

java异常处理机制

• java中所有错误的超类为:Throwable。其下有两个子类:Error和Exception
• Error的子类描述的都是系统错误，比如虚拟机内存溢出等。
• Exception的子类描述的都是程序错误，比如空指针，下表越界等。
• 通常我们程序中处理的异常都是Exception

异常处理机制中的try-catch

/**
* 异常处理机制中的try-catch
* 语法:
* try{
* 代码片段...
* }catch(XXXException e){
* 出现错误后的补救措施(B计划)
* }
*/
public class TryCatchDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        /*
        try{}语句块不能单独写，后面要么跟catch语句块要么跟finally语句块
        异常处理机制关注的是:明知道程序可能出现某种错误，但是该错误无法通过修改逻辑
        完全规避掉时，我们会使用异常处理机制，在出现该错误是提供一种补救办法。
        凡是能通过逻辑避免的错误都属于bug！就应当通过逻辑去避免!
        */
        try {
            // String str = null;
            // String str = "";
            String str = "a";
            /*
            若str=null的情况
            当JVM执行到下面代码时:str.length()会出现空指针，此时虚拟机就会根据该情况
            实例化一个对应的异常实例出来，即:空指针异常实例 NullPointerException实例
            然后将程序从一开始执行到报错这句话的过程设置到该异常实例中，此时该异常通过
            类型名字可以表达出现了什么错误，并将来可以通过输出错误信息来得知错误出现在那里
            虚拟机会将该异常抛出
            当某句代码抛出了一个异常时，JVM会做如下操作:
            1:检查报错这句话是否有被异常处理机制控制(有没有try-catch)
            如果有，则执行对应的catch操作，如果没有catch可以捕获该异常则视为没有
            异常处理动作
            2:如果没有异常处理，则异常会被抛出当当前代码所在的方法之外由调用当前方法的
            代码片段处理该异常
            */

            System.out.println(str.length());//抛出空指针异常
            System.out.println(str.charAt(0));
            System.out.println(Integer.parseInt(str));

            /*
            当try中某句代码报错后，就会跳出try执行下面对应的catch块，执行后就会
            退出catch继续向后执行。因此try语句块中报错代码以下的内容都不会被执行
            */

            System.out.println("!!!!!!!!!!!!!!");
            // }catch(NullPointerException e){
            // //这里实际开发中是写补救措施的，通常也会将异常信息输出便于debug
            // System.out.println("出现了空指针，并解决了!");
            // }catch(StringIndexOutOfBoundsException e){
            // System.out.println("处理字符串下标越界问题!");
            // }
            /*
            当try语句块中可能出现的几种不同异常对应的处理办法相同时，可以采取合并
            catch的做法，用同一个catch来捕获这几种可能出现的异常，而执行措施使用
            同一个。
            */
        }catch(NullPointerException|StringIndexOutOfBoundsException e){
            System.out.println("处理空指针或下标越界!");
            /*
            当catch捕获某个超类型异常时，那么try语句块中出现它类型异常时都可以被这个
            catch块捕获并处理。
            如果多个catch捕获的异常之间存在继承关系时，一定是子类异常在上超类异常在下
            */
        }catch(Exception e){
            System.out.println("反正就是出了个错!");
        }
        System.out.println("程序结束了...");
    }
}

异常处理机制中的finally

• finally块定义在异常处理机制中的最后一块。它可以直接跟在try之后，或者最后一个catch之后。
• finally可以保证只要程序执行到了try语句块中，无论try语句块中的代码是否出现异常，最终finally 都必定执行。
• finally通常用来做释放资源这类操作。

/**
* finally块
* finally块是异常处理机制中的最后一块，它可以直接跟在try语句块之后或者最后一个catch块
* 之后。
* finally可以保证只要程序执行到try语句块中，无论try语句块中的代码是否出现异常，finally
* 都【必定执行】!
* 通常finally块用于做释放资源这类操作，比如IO操作后的关闭流动作就非常适合在finally中进行
*/
public class FinallyDemo {
    public static void main(String[] args) {
        System.out.println("程序开始了...");
        try{
            String str = "abc";
            System.out.println(str.length());
            return;
        }catch(Exception e){
            System.out.println("出错了，并处理了");
        }finally{
            System.out.println("finally中的代码执行了!");
        }
        System.out.println("程序结束了");
    }
}

throw关键字

throw用来对外主动抛出一个异常，通常下面两种情况我们主动对外抛出异常

1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。

2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。

/**
* 测试异常的抛出
*/
public class Person {
    private int age;

    public int getAge() {
        return age;
    }
    public void setAge(int age) throws Exception {
        if(age<0||age>100){
        //使用throw对外抛出一个异常
        throw new RuntimeException("年龄不合法!");
        throws关键字
        当一个方法中使用throw抛出一个非RuntimeException的异常时，就要在该方法上使用throws声明这个
        异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译不通过。
        当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通
        过。 处理手段有两种:
        使用try-catch捕获并处理这个异常
        在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。 具体选取
        那种取决于异常处理的责任问题。
        }
        this.age = age;
        }
}


/**
* throw关键字，用来对外主动抛出一个异常。
* 通常下面两种情况我们主动对外抛出异常:
* 1:当程序遇到一个满足语法，但是不满足业务要求时，可以抛出一个异常告知调用者。
* 2:程序执行遇到一个异常，但是该异常不应当在当前代码片段被解决时可以抛出给调用者。
*/
public class ThrowDemo {
    public static void main(String[] args) {
        Person p = new Person();
        p.setAge(10000);//符合语法，但是不符合业务逻辑要求。
        System.out.println("此人年龄:"+p.getAge());
    }
}

throws关键字

当一个方法中使用throw抛出一个非RuntimeException的异常时，就要在该方法上使用throws声明这个 异常的抛出。此时调用该方法的代码就必须处理这个异常，否则编译不通过。

/**
* 测试异常的抛出
*/
public class Person {
    private int age;
    public int getAge() {
        return age;
    }
    /**
    * 当一个方法使用throws声明异常抛出时,调用此方法的代码片段就必须处理这个异常
    */
    public void setAge(int age) throws Exception {
        if(age<0||age>100){
            //使用throw对外抛出一个异常
            // throw new RuntimeException("年龄不合法!");
            //除了RuntimeException之外,抛出什么异常就要在方法上声明throws什么异常
            throw new Exception("年龄不合法!");
        }
        this.age = age;
    }
}

当我们调用一个含有throws声明异常抛出的方法时，编译器要求我们必须处理这个异常，否则编译不通 过。 处理手段有两种:

• 使用try-catch捕获并处理这个异常
• 在当前方法(本案例就是main方法)上继续使用throws声明该异常的抛出给调用者解决。 具体选取 那种取决于异常处理的责任问题。

• /**
  * throw关键字，用于主动对外抛出一个异常
  */
  public class ThrowDemo {
      public static void main(String[] args){
          System.out.println("程序开始了...");
          try {
              Person p = new Person();
              /*
              当我们调用一个含有throws声明异常抛出的方法时,编译器要求
              我们必须添加处理异常的手段,否则编译不通过.而处理手段有两种
              1:使用try-catch捕获并处理异常
              2:在当前方法上继续使用throws声明该异常的抛出
              具体用哪种取决于异常处理的责任问题
              */
              p.setAge(100000);//典型的符合语法，但是不符合业务逻辑要求
              System.out.println("此人年龄:"+p.getAge()+"岁");
          } catch (Exception e) {
              e.printStackTrace();
          }
          System.out.println("程序结束了...");
      }
  }
  

  注意，永远不应当在main方法上使用throws!!