java第八章----异常

Java 异常概述

异常： 指的是程序在执行过程中，出现的非正常情况，如果不处理最终会导致 JVM的非正常停止。

注： 异常指的并不是语法错误。语法错了，编译不通过，不会产生字节码文 件，根本不能运行。

java中默认的异常处理机制：将出现的异常，按不同的类型分类，为每种异常封装了一个类来进行表示，
当出现某种类型的异常情况时，会抛出此类的对象，然后终止虚拟机的运行，
使用异常处理机制，对程序运行过程中出现的异常情况进行捕捉并处理 

常见的异常

public static void main(String[] args) {
   /* int a=10;
    int b=0;
    System.out.println(a/b);//ArithmeticException  算数异常*/

   /* int[] c=new int[2];
    c[3]=0;  //ArrayIndexOutOfBoundsException    数组索引越界*/

    /*String s="abc";
    s.charAt(4);  //StringIndexOutOfBoundsException   字符串索引越界*/

   /* Object a=new Integer(10);
    String s1=(String) a;  //ClassCastException   类型转换异常*/

    //Integer.parseInt("aba"); //  NumberFormatException  数字格式化异常

   /* String s=null;
    s.length();   //NullPointerException   使用null中方法/属性  在java中称为空指针异常*/
}

异常处理

Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws

异常处理：
在编码时，就针对可能出现的问题的代码提前编写一些处理机制，
程序运行
出现异常
执行处理机制‘继续运行后续的程序

try{
编写可能出现异常的代码
算数异常
}catch(异常类型){
处理机制
}

●try 检测不安全的代码块（发现异常） try块中任何一条语句发生了异常，下面的代码将不会被执行，程序将 跳转到异常处理代码块中，即catch块。因此，不要随意将不相关的代 码放到try块中，因为随时可能会中断执行。

● catch 把抓到的类型匹配的异常捕获，保证程序能继续运行下去 catch语句必须紧跟着try语句之后，称为捕获异常，也就是异常处理函数， 一个try后面可以写多个catch，分别捕获不同类型的异常，要从子类往父类 的顺序写，否则有编译错误

捕获异常的有关信息： 与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法。 • getMessage() 获取异常信息，返回字符串 • printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的 位置。返回值void。

● finally finally该内容总是会执行的，只能有一个finally语句

finally{ 必须执行的逻辑 }

● throws,定义一个方法的时候可以使用throws关键字声明,表示此方法 不处理异常，而交给方法调用处进行处理。 例如: public void test throws 异常1，异常2，异常3{ }

● 任何方法都可以使用throws关键字声明异常类型，包括抽象方法。

● 调用使用了throws的方法时必须处理声明的异常，要么使用try-catch，要么 继续使用throws声明。

● 如果抛出的是运行期异常,则不会有任何提示,需要查看所调用的方法结构.

public static void main(String[] args) throws IOException {
    int[] arr = new int[3];
    String s = "abc";
    FileInputStream inputStream = null;
    try {
       /* s.charAt(4);
        arr[4]=5;*/
        inputStream = new FileInputStream("H:/demo.txt");
    } catch (ArrayIndexOutOfBoundsException ai) {
        ai.printStackTrace();
        System.out.println("数组索引越界");
    } catch (StringIndexOutOfBoundsException sb) {
        sb.printStackTrace();
        System.out.println("字符串索引越界，越界位置：" + sb.getMessage());
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (inputStream != null) {
            inputStream.close();
        }
        System.out.println();
    }

}

运行期异常和编译期异常

● 编译时期异常（即checked异常、受检异常）：在代码编译阶段，编译器就能明 确警示当前代码可能发生（不是一定发生）XX异常，并明确督促程序员提前编写 处理它的代码。如果程序员没有编写对应的异常处理代码，则编译器就会直接判 定编译失败，从而不能生成字节码文件。通常，这类异常的发生不是由程序员的 代码引起的,例如：FileNotFoundException（文件找不到异常）。

● 运行时期异常（即runtime异常、unchecked异常、非受检异常）：在代码编译 阶段，编译器完全不做任何检查，无论该异常是否会发生，编译器都不给出任何 提示。只有等代码运行起来并确实发生了XX异常，它才能被发现。通常，这类异 常是由程序员的代码编写不当引起的，只要稍加判断，或者细心检查就可以避免

public class exceptiondemo01 {
    public static void main(String[] args) {
        try {
            mothA();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            System.out.println("编码异常");
        }
    }
    public static  void mothA() throws UnsupportedEncodingException {
        mothB();
        System.out.println("mothA");
    }
/*
mothodb方法模拟一个底层方法
throw 异常类型 声明表示此方法中可能会出现给定的异常，并且该方法不处理异常
谁调用谁处理
 */
    public static  void  mothB() throws UnsupportedEncodingException {
        String s="abc";
        s.getBytes("gbk-1");
        System.out.println("mothB");
    }

public static void main(String[] args) {
    mothA(new int[5]);
        System.out.println("main");
    }

    public static void mothA(int[] a){
mothB(a);
        System.out.println("motha");
    }
    /*
    异常（Exeception）分为
       检查期异常：在编译期间就会主动提示程序员要进行的处理，
       运行期异常：在编译期间不会主动提示程序员进行处理的异常
       区别在于异常类有没有继承RuntimeException
     */
    public static void  mothB(int[] a)throws ArrayIndexOutOfBoundsException{
a[5]=0;
    }

自定义异常

throws:用在方法声明部分，表示此方法中有可能出现某种类型的异常，此方法不处理异常，谁调用谁处理

throw: 在方法体中，抛出一个具体的异常对象，该方法终止运行，在异常对象中的构造方法中自定义异常原因

● 自定义异常类中往往不写其他方法，只重载需要使用的构造方法

● 继承Exception,在方法中使用throw抛出后,必须在方法中try-catch或 throws抛出

/*
根据自己的业务需求定义异常类型----自定义异常

分数自定义异常
  当分数不合法时抛出此类的对象
 */
public class scoreexception extends Exception{

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

public static void main(String[] args) {
    try {
        leavl(101);
    } catch (exceptiondemo.scoreexception scoreexception) {
        scoreexception.printStackTrace();
    }
    System.out.println("abc");
}
/*
throws:用在方法声明部分，表示此方法中有可能出现某种类型的异常，此方法不处理异常，谁调用谁处理

throw: 在方法体中，抛出一个具体的异常对象，该方法终止运行，在异常对象中的构造方法中自定义异常原因
 */
public static char leavl(int score)throws scoreexception{
    if(score<0||score>100){
        throw new scoreexception("分数越界");//当不满足某种条件是时，程序中主动的抛出异常对象，终止此方法继续进行，通过异常构造方法传入异常原因
    }
 if(score<=100||score>90){
  return 'A';
}
  return 'B';
}

 用自定义异常标记业务逻辑的异常，避免与标准异常混淆