Java异常

时间:2022-06-03 厚积薄发ض 人气:0

什么是异常？

异常在我们写代码是特别常见，因为程序员大部分时间都在修复bug，在java中通过throwable顶层类又可以分为两个，一个是Error（错误），一个是Exception(异常)。

Error(错误) : Error与异常不同的是，错误并不能处理，而是程序员造成的问题，比如语法错误那就要程序员检查自己的语法，比如结果错误(StackOverflowError和OutOfMemoryError

)，那就要程序员检查自己的逻辑。

Exception(异常) : 这个可以通过一些方式来处理，比如我们后面要讲的throws(声明异常)，try{}catch{}(处理异常)这都是我们处理异常的方式，而异常又分为受查异常(编译时异常)和非受查异常(运行时异常RuntimeException)。

编译时异常：程序不能通过编译，就是编译时异常，比如：clone时必须要通过throws来声明异常

运行时异常：指的是程序能通过编译，但是运行时出现异常。比如：NullPointerException、

ArrayIndexOutOfBoundsException、ArithmeticException。

以上的异常我们都能进行处理解决，但是错误需要程序员自己检查代码。

异常的处理

我们有两种方式来来进行处理：

一种是事前防御型：

boolean ret = false;
ret = 登陆游戏();
if (!ret) {
处理登陆游戏错误;
return;
} r
et = 开始匹配();
if (!ret) {
处理匹配错误;
return;
} r
et = 游戏确认();
if (!ret) {
处理游戏确认错误;
return;
} r
et = 选择英雄();
if (!ret) {
处理选择英雄错误;
return;
} r
et = 载入游戏画面();
if (!ret) {
处理载入游戏错误;
return;
} .
.....

事前防御型就是每一步都要检查是否出现了错误，这样的缺点就是代码显得很混乱，效率低下；

一种是事后认错型：

try {
登陆游戏();
开始匹配();
游戏确认();
选择英雄();
载入游戏画面();
...
} catch (登陆游戏异常) {
处理登陆游戏异常;
} catch (开始匹配异常) {
处理开始匹配异常;
} catch (游戏确认异常) {
处理游戏确认异常;
} catch (选择英雄异常) {
处理选择英雄异常;
} catch (载入游戏画面异常) {
处理载入游戏画面异常;
} .
....

这种做法就是将所有代码可能出现的异常全部放在try里，如果发现异常在进行捕获，这种就是先进行操作遇到问题在进行处理。

我们常常使用第二种trycatch这样使代码简洁，清晰，效率更高。

异常的抛出

如果哪段代码不符合你的预期，这段代码我们就要抛出异常，java中我们通过关键字throw来抛出异常。

语法是 throw new 异常(你要抛出的异常)

public class TestDemo {
    public static void func(int a) {
        if(a==10) {
            throw new RuntimeException("a==10不符合预期，抛出这个异常");
        }
    }
    public static void main(String[] args) {
           func(10);
    }
}

看这段代码：比如我们10这个数字不符合我们程序的预期，所以要抛出异常，我们就可以这样跑出： throw new RuntimeException("a==10不符合预期，抛出这个异常");

处理异常

我们通常有两种方式来处理异常，一种是通过throws声明异常，一种是通过try{}catch{}通过try检查代码块里是否有异常，如果有异常catch就进行捕获，如果没有异常就正常下面的代码。

throws声明异常

语法：throws 异常，异常，异常......(可声明多个异常)

public class TestDemo {
    public static void function(int[] array) {
        System.out.println(array[100]);
    }
    public static void main(String[] args) {
        int[] array = {7, 8, 9, 5, 6};
        function(array);
    }
}

大家都知道这里访问100下标是数组越界异常：

接下来通过throws来声明异常：

还是会报错。

当我们也给主函数声明异常：

答案依然会报错。

所以从这里我们得出了一个结论：通过throws只是告诉编译器，这个方法可能会发生这个异常，只是声明，但是并没有进行处理异常。我们还可以发现，如果某一个方法出现了异常，那就会看这个方法有没有处理异常，如果没有处理就去看一看上层调用者有没有处理异常。这里就是func只是声明了异常，并没有进行处理异常，然后去上层调用者有没有处理异常(也就是main方法)还是没有处理异常，最后就交给JVM来处理进行终止程序。声明的异常必须是 Exception 或者 Exception 的子类。

那怎么进行处理异常呢？？那就要通过我们接下来讲解的try{}catch来进行处理异常。

捕获异常

try{

}catch(){

}

在Java我们利用try{}catch{}来处理异常；

语法：

    try{
     //可能发生异常的代码
    }catch(异常 变量){//例如：ArrayIndexOutOfBoundsException(要捕获的异常) e(变量)
      //如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，
      //或者是try中抛出异常的基类时，就会被捕获到
      // 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
    }finally{
      //此处代码一定会执行，用于资源清理扫尾等工作
    }

我们先来讲一下try{}catch(){}

/*在方法中处理异常*/
public class TestDemo {
    public static void function(int[] array) throws ArrayIndexOutOfBoundsException {
        try{
            System.out.println(array[100]);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->数组下标越界异常catch->捕获成功");
        }
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
        int[] array = {7, 8, 9, 5, 6};
        function(array);
    }
}
/*在main方法中处理异常*/
public class TestDemo {
    public static void function(int[] array) throws ArrayIndexOutOfBoundsException {
            System.out.println(array[100]);
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException {
        int[] array = {7, 8, 9, 5, 6};
        try{
            function(array);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->数组下标越界异常catch->捕获成功");
        }
    }
}

我们使用try{}catch(){}就可以对异常进行处理，既可以在方法中处理异常也可以在main方法中处理异常，同时这里throws虽然没有什么用处，但是可以清晰的告诉程序员，这个方法未来可能会发生这个异常，所以还是有必要的。

try{}catch{}注意点一：

当捕获异常成功的时候，后面的业务代码正常执行，如果没有捕获那就不会执行。

try{}catch{}注意点二：

当try里检查到异常，catch就会捕获，计算这个异常后面还有异常也不会执行。

try{}catch{}注意点三：

throws只是声明异常，并没有处理异常，我们要通过try{}catch(){}来处理异常。

try{}catch{}注意点四：

当catch捕获的异常类型与发生异常类型不符合，就不会被捕获，就继续往外抛异常知道JVM收到后终止程序

try{}catch{}注意点五：

当发生多种异常的时候，那就要多种catch来捕获，多种异常，多次捕获。

try{}catch{}注意点六：

Exception是所有类的父类不能在前面捕获，而是应该放在最末尾进行收尾工作。

既然Exception类是所对应异常类的父类，那可不可以捕获Exception，即多次异常，一次捕获呢？？

catch 进行类型匹配的时候, 不光会匹配相同类型的异常对象, 也会捕捉目标异常类型的子类对象

答案是不建议的。因为当代码进行复杂的时候，只捕获Exception类并不知道究竟是什么处理出了问题。

打印异常信息

我们还可以利用printStackTrace来打印错误信息。

finally:

finally经常与try{}catch(){}进行一起使用，finally主要是进行资源的清理，的扫尾工作，且finally一定会被执行。

我们来看这样一段代码结果会是什么？？

public class TestDemo {
    public static int function(int[] array) throws ArrayIndexOutOfBoundsException {
        try {
            System.out.println(array[100]);
        }catch(ArrayIndexOutOfBoundsException e) {
            System.out.println("array[100]->数组下标越界异常catch->捕获成功");
            return -1;
        }finally{
            System.out.println("finally主要进行资源回收和清理的扫尾工作~~~");
            return 9;
        }
    }
    public static void main(String[] args) throws ArrayIndexOutOfBoundsException,ArithmeticException {
        int[] array = {7, 8, 9, 5, 6};
        System.out.println(function(array));
        System.out.println("以下是业务代码~~~~~~");
    }
}

答案并不是我们想的return-1,执行结束，而是return9，我们这里可以理解为finally的9将catch里的-1覆盖。所以finally里面的代码是一定会执行的。

异常的处理流程

我的理解：

第一步检查try里面的代码里是否有异常，如果有异常catch就进行捕获，如果没有异常接着往下执行，这里catch如果没有捕获到就看一看上层调用者有没有处理，有处理就进行处理，没有处理就交给JVM终止程序。如果catch捕获到了，下面正常的业务代码正常执行。最后无论catch是否捕获到了异常，finally里面的代码都会执行。

官方：

程序先执行 try 中的代码
如果 try 中的代码出现异常, 就会结束 try 中的代码, 看和 catch 中的异常类型是否匹配.
如果找到匹配的异常类型, 就会执行 catch 中的代码
如果没有找到匹配的异常类型, 就会将异常向上传递到上层调用者.
无论是否找到匹配的异常类型, finally 中的代码都会被执行到(在该方法结束之前执行).
如果上层调用者也没有处理的了异常, 就继续向上传递.
一直到 main 方法也没有合适的代码处理异常, 就会交给 JVM 来进行处理, 此时程序就会异常终止。

自定义异常

在我们做很大型的项目的时候，我们就会发现，我们遇到的异常，在Java中的内置异常并没有，所以我们就需要自己定义一个异常，来维护我们实际中遇到的异常。

java 中虽然已经内置了丰富的异常类, 但是并不能完全表示实际开发中所遇到的一些异常，此时需要维护符合我们实际情况的异常结构

在Java中自己声明异常，不是说你写了个异常的名字就是一个异常，而是在你自己定义的异常需要取继承原有的内置异常。

我们通过一个登陆的代码来讲解自定义异常：

class LogIn {
    private String name ="Admin";//用户名
    private String password= "CsDn1263987..0";
    public void logInFor(String name,String password) throws UserNameErrorExecption, PasswordErrorException {
        if(!this.name.equals(name)){
            throw new UserNameErrorExecption("用户名参数异常！！！");
        }
        if(!this.password.equals(password)) {
            throw  new PasswordErrorException("用户密码参数异常！！！");
        }
        System.out.println("~~~登陆成功~~~");
    }
}
public class TestDemo{
    public static void main(String[] args) throws UserNameErrorExecption, PasswordErrorException {
        LogIn logIn = new LogIn();
        //logIn.logInFor("Admin","CsDn1263987..0");
        try{
            logIn.logInFor("Admin","CsDn126398..0");
        }catch(UserNameErrorExecption nameError) {
            nameError.printStackTrace();
            System.out.println("用户名错误！！！");
        }catch(PasswordErrorException passwordError) {
            passwordError.printStackTrace();
            System.out.println("密码错误！！！");
        }
    }
}

自定义异常：

class PasswordError extends Exception {
     public PasswordError(String message) {
           super(message);
     }
}

class UserNameError extends Exception {
    public UserNameError(String message) {
        super(message);
    }
}

这就是我们定义的两个异常。

通过继承Exception来定义两个异常。

一般我们自定义异常要继承Exception或者是RunTimeException，定义其他的也可以。

自定义异常通常会继承自 Exception 或者 RuntimeException
继承自 Exception 的异常默认是受查异常
继承自 RuntimeException 的异常默认是非受查异常

加载全部内容