Java异常

异常

异常的概念：程序在编译时出现意想不到的情况，一般分为两类，错误（error）和异常（Exception）（而通常我们讲的异常值得是后面的异常，而不是错误）

异常分为编译时异常和运行时异常，编译时异常必须处理，编译时程序会报错，而运行时异常，编译时程序不会报错。

程序有时也会出现错误，但是不在异常范围内

/*错误：jvm无法解决
        * 错误原因： java.lang.StackOverflowError
        * 方法在栈中调用，栈中堆满了方法，栈溢出*/
//        常见异常 a=new 常见异常();
        a.add(5);
 public int add(int a){
​
        return a+add(a);
    }

常见的异常有：

空指针异常：

产生原因：对象没有创建就访问元素或者方法或者属性

/*空指针异常  java.lang.NullPointerException
        * 异常位置：(常见异常.java:15)
        * */
       Object a=null;
System.out.println(a.toString());

算术异常：

 /*算术异常  java.lang.ArithmeticException
 异常原因： / by zero
 异常位置：at javaExcption.常见异常.main(常见异常.java:6)*/
​
        int a=10;
        System.out.println(10/0);

​

类型转换异常：

/*转换异常：java.lang.ClassCastException
        * 异常原因：java.lang.String cannot be cast to java.lang.Integer
        * 异常位置：at javaExcption.常见异常.main(常见异常.java:38)*/
        Object a="abc";
        Integer b=(Integer) a;
        System.out.println(b);

数组越界异常：

产生原因：访问了不存在的索引

/*数组越界异常  java.lang.ArrayIndexOutOfBoundsException
        * 异常原因：5
        * 异常位置：at javaExcption.常见异常.main(常见异常.java:21)*/
        int [] a=new int[5];
        System.out.println(  a[5]=10);

解决异常：通常使用try{}catch{}或者throws或者throw

1.使用try{}catch{}解决

public class day1 {
    public static void main(String[] args) {
        int a=10;
        try {
            int b=a/0;
             System.out.println("try面的代码");
        }catch (Exception e){
            System.out.println("算术异常");
        }
        System.out.println("try  catch后面的代码");
    }
}
//执行结果
​
/*算术异常
try  catch后面的代码
*/

发现异常，try里面的代码不会执行，而会跳转到catch里面执行它里面的代码，执行完之后再执行try catch外面后续的代码，因为catch进行了异常处理

也可以使用try catch catch，异常范围小的写前边，大的写后面，当一次向下catch时，遇到匹配的，则会执行catch里面的语句然后跳过后面全部的catch，

throws

声明此方法中可能出现异常，抛出异常，不做处理，向上抛出,程序将异常一直向上层抛出，倘如上次无法解决，一直到dvm，也无法解决，程序中止，jvm会打印出异常，程序结束，发现异常代码哪一行后面的代码也不会执行，如果某层解决了，则程序会接着向下执行

public class day1 {
​
​
    public static void main(String[] args) throws Exception {
        int a = 10;
        int b = a / 0;
        System.out.println("try面的代码");
        System.out.println("try catch后面的代码");
​
    }
}
//执行结果
​
/*Exception in thread "main" java.lang.ArithmeticException: / by zero
    at day1.main(day1.java:9)
​
Process finished with exit code 1*/
​

throw

在此方法中抛出一个异常对象，倘如没有解决异常，方法中止，不会继续向下执行

也是自定义异常，根据实际业务来定义某一种情况的异常类，表示一种业务需求

throw new 异常类型 （异常名）

public class day1 {
        public static void divide() throws Exception {
            int a = 10;
            int c = 0;
            if (c == 0) {
                throw new Exception("异常参数");
            } else {
                int b = a / c;
            }
        }
​
    public static void main(String[] args) throws Exception {
        divide();
        System.out.println("try面的代码");
        System.out.println("try catch后面的代码");
​
    }
}
​
//运行结果
​
/*Exception in thread "main" java.lang.Exception: 异常参数
    at day1.divide(day1.java:10)
    at day1.main(day1.java:17)
​
Process finished with exit code 1*/

​

如果在后面解决处理了异常，则程序还会继续向下执行,也会执行后面的代码

public class day1 {
        public static void divide() throws Exception {
            int a = 10;
            int c = 0;
            if (c == 0) {
                throw new Exception("异常参数");
            } else {
                int b = a / c;
            }
        }
​
    public static void main(String[] args)  {
        try {
            divide();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("catch里面语句");
        }
        System.out.println("try面的代码");
        System.out.println("try catch后面的代码");
​
    }
}
​
/*运行结果：
java.lang.Exception: 异常参数
    at day1.divide(day1.java:10)
    at day1.main(day1.java:18)
catch里面语句
try面的代码
try catch后面的代码
​
Process finished with exit code 0
*/
​

finally

finally可以和try catch使用，也可以和try使用，也可以try catch catch....finally使用

package javaExcption;
​
public class tryCatchFinally {
    public static void main(String[] args) {
       /* int a=10;
        try {
            int c=a/0;
        }catch (Exception e){
            System.out.println("算术异常");
        }finally {
            System.out.println("finally");
        }
        System.out.println("后面的代码");*/
        System.out.println( divide());
    }
    public static int divide(){
        int a=10;
        int b=0;
        try {
            int c=a/b;
            return c;
        }catch (Exception e){
            System.out.println("catch");//这句执行完，则会跳转到finally中的sout，执行完后在回来执行这句后面的retuen；
            return -1;
        }finally {
            System.out.println("方法中的finally");
        }
​
    }
}
​
/*当程序运行结束前，一定会在执行finally，这个在跳到catch里面时，执行完上面，并没有执行return语句，而是进入到finally执行完才跳转回去*/

在别的没有return时，不会跳出方法让finally不执行的语句中，则会依次向下执行，先try，后catch，再是finally

import java.io.UnsupportedEncodingException;
import java.util.Calendar;
import java.util.GregorianCalendar;
​
public class day1 {
        public static void divide() throws Exception {
            int a = 10;
            int c = 0;
            if (c == 0) {
                throw new Exception("异常参数");
            } else {
                int b = a / c;
            }
        }
​
    public static void main(String[] args)  {
        try {
            divide();
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("catch里面语句");
        }finally{
            System.out.println("执行fanally语句");
        }
       /* System.out.println("try面的代码");
        System.out.println("try catch后面的代码");*/
​
    }
}
/* 执行结果：
java.lang.Exception: 异常参数
    at day1.divide(day1.java:10)
    at day1.main(day1.java:18)
catch里面语句
执行fanally语句
​
Process finished with exit code 0
*/

在底层方法尽量用throws抛出，不使用try catch

抽象类中也可以使用异常

/*继承抽象类的类，他们的方法名一样，参数列表一样，访问权限要么比父类大，要么与父类保持一致
* 子类在继承父类方法时，父类如果抛出异常，子类必须也抛出异常
* 并且子类抛出的异常要么与父类保持一致，要么子类异常必须是父类异常的子类* */