Java零基础讲解异常（java异常处理常见问题）

Java零基础讲解异常（java异常处理常见问题）

目录什么是异常？异常的处理异常的抛出处理异常throws声明异常捕获异常finally:异常的处理流程自定义异常

什么是异常？

异常在我们写代码是特别常见，因为程序员大部分时间都在修复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;} ret = 开始匹配();if (!ret) {处理匹配错误;return;} ret = 游戏确认();if (!ret) {处理游戏确认错误;return;} ret = 选择英雄();if (!ret) {处理选择英雄错误;return;} ret = 载入游戏画面();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 的异常默认是非受查异常

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。