java异常

1.异常的原因和分类

1.1异常的原因

在java中异常的产生主要有以下三种原因：

（1）编写程序代码中的错误产生的异常，比如数组越界、空指针异常等，这种异常叫做未检查的异常，一般需要在类中处理这些异常。

（2）Java内部错误发生的异常，Java虚拟机产生异常。

（3）通过throw（抛出异常）语句手动生成的异常，这种异常叫做检查的异常，一般是用来给方法调用者一些必要的信息。

1.2异常的分类

异常的分类我将用一张图来展示

  java.lang.Throwable 是java异常体系中的根类。
      里面有两个常用的方法：
          public void printStackTrace(); 打印栈中的异常信息。
          public String getMessage();  获取到异常信息。
        有两个子类：
          java.lang.Error: 错误 是java程序无法处理的，例如内存不够用了
          
          java.lang.Exception: 异常，出现的一般性问题，可以使用java中 

2.常见的异常

以下用代码举例六种java中常见的异常

public class Demo1 {
    public static void main(String[] args){
        /*int[] a=new int[5];
        a[5]=5; //数组越界   ArrayIndexOutOfBoundsException*/
       /* String s="zrh";
        s.charAt(3);  //字符串数组越界  StringIndexOutOfBoundsException*/
        /*int a=10;
        int b=0;
        int c=a/b;  //算数异常   ArithmeticException*/
       /* String s=null;
        s.length();  //空指针异常   NullPointerException*/
       /*  Object s="abcd";
        Integer a=(Integer)s;  //类型转换异常  ClassCastException*/
        /*int a=Integer.parseInt("zrh");  //数字格式异常 NumberFormatException*/
        System.out.println("狒狒");
    }
}

常见的异常：

异常-----运行时的异常

数组越界（ ArrayIndexOutOfBoundsException），字符串数组越界（

StringIndexOutOfBoundsException），
算术异常（ArithmeticException），
空指针异常（NullPointerException），
类型转换异常（ClassCastException），
数字格式异常（NumberFormatException）。

import java.util.ArrayList;
import java.util.Date;

public class Demo2 {
    public static void main(String[] args){
        /*ArrayList arrayList=new ArrayList();
        while(true){
            arrayList.add(new Date());
        }
        //OutOfMemoryError 堆爆了（存放对象的空间）*/
        sum(1000000);
        //StackOverflowError 栈溢出
    }
    public static int sum(int n){
        if(n==1){
            return 1;
        }
        else
        {
            return sum(n-1);
        }
    }
}

常见的异常：

Error:

堆溢出: OutOfMemoryError

栈溢出: StackOverflowError

3.异常的处理

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

基本语法：

try{
       写可能会出现异常的代码
       }
       
       catch(){捕获出现的指定的异常对象，如果类型不匹配，就捕获不到。
       
       }

public class Demo3 {
  /*  关键字
	   try{
        写可能会出现异常的代码
    }

	   catch(){捕获出现的指定的异常对象，如果类型不匹配，就捕获不到。

    }

	   finally{

    }

	   throw

       throws*/

    public static void main(String[] args){
        try{
            int a=10;
            int b=0;
            int c=a/b;

        }
        catch(ArithmeticException a){
            a.printStackTrace();//开发期间建议使用，打印异常信息
            System.out.println("算术异常"+a.getMessage());
        }
    }
}

如果try中的语句的异常符合catch语句中对异常的判断，则执行catch语句中的内容。

try{
       写可能会出现异常的代码
       }

  catch(){捕获出现的指定的异常对象，如果类型不匹配，就捕获不到。
       
       }

finally{

       必须执行的逻辑

      }

public class Demo4 {
    public static void main(String[] args){
        try{
            String s=null;
            s.length();
        }
        catch( NullPointerException a){
            a.printStackTrace();
            System.out.println("空指针异常");
        }
        finally {
            System.out.println("必须执行的内容");
        }
    }
}

finally内的语句是必须执行的内容，即使上面的语句出现异常也不妨碍finally中语句的执行。

public class Demo5 {
   /* try{
        可能会发生异常的代码
    }catch(异常类型 引用名){
        异常处理代码
    }finally{
        必须执行代码
    }*/
    public static void main(String[] args){
        try{
            String s=null;
            s.length();
        }
        catch( NullPointerException a){//当catch() 出现异常时
            int b=Integer.parseInt("zrh");
            a.printStackTrace();
            System.out.println("空指针异常");
        }
        finally {
            System.out.println("必须执行的内容");
        }
    }
}

以上代码,catch中的语句出现异常，但在运行结果中仍然执行了finally中的语句块，输出了“必须执行的内容”。

4.运行期异常和编译期异常

5.自定义异常