Java基础--异常-CSDN博客

本文链接：https://blog.csdn.net/kdy1122/article/details/44031737

一、异常的概念

异常也称为例外，是在程序运行过程中发生的、会打断程序正常执行的事件，西面是几种常见的异常：

1、算术异常（ArithmeticException）。

2、没有给对象开辟内存空间时会出现空指针异常（NullPointerException）。

3、找不到文件异常（FileNotFoundException）。

二、异常的体系

Throwable类的继承关系图

Throwable

|--Error 严重问题，我们不处理。

|--Exception

|--RuntimeException 运行期异常，我们需要修正代码

|--非RuntimeException 编译期异常，必须处理的，否则程序编译不通过

三、异常的处理

A: JVM的默认处理

把异常的名称,原因,位置等信息输出在控制台，但是呢程序不能继续执行了。

B: 自己处理

a:try...catch...finally

自己编写处理代码,后面的程序可以继续执行

b:throws

把自己处理不了的，在方法上声明，告诉调用者，这里有问题

a：Try-catch-finally语法结构

1、try程序块若是有异常发生时，程序的运行便中断，并抛出“异常类所产生的对象”。

2、抛出的对象如果属于catch（）括号内欲捕捉的异常类，则catch会捕捉此异常，然后进到catch的块里继续运行。

3、无论try程序块是否有捕捉到异常，或者捕捉到的异常是否与catch（）括号里的异常相同，最后一定会运行finally块里的程序代码。

finally的程序代码快运行结束后，程序再回到try-catch-finally块之后继续执行。

分析：由上述的过程可知，异常捕捉的过程中做了两个判断：第一个是try程序块是否有异常产生，第二个是产生的异常是否和catch（）括号内的欲捕捉的异常相同。

值得一提的是，finally块是可以省略的。如果省略了finally块不写，则在catch（）块运行结束后，程序跳到try-catch块之后继续执行。

异常处理流程图

范例1

public class TestException1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{                            //检查这个程序代码快是否有异常产生。
		<span style="white-space:pre">	</span>int arr[] = new int[5];// 声明一arr的整型数组，并开辟了5个数据空间。
		<span style="white-space:pre">	</span>arr[10] = 7;           //  为整数组中的第10个元素赋值，此时已经超出了该数  组本身的范围，所以会出现异常。                 
		}
		catch(ArrayIndexOutOfBoundsException e){     //catch捕捉到了异常，生成一个对象e，利用此对象得到     
                                                                异常类所产生的相关信息。
			System.out.println("数组超出绑定范围");
			System.out.println("显示异常对象e的内容"+e);//输出异常类的种类。
		}
		finally{                                      //这个程序代码快一定会执行
			System.out.println("这里一定会被执行");
		}
		System.out.println("end of main() method!!");
				
	}

}

b：throws抛出异常

1、在程序中抛出异常

范例2

public class TestException2 {
	public static void main(String args[]){
		int a= 4,b=0;
		try{
			if(b==0)                                                //判断b是否为0
				throw new ArithmeticException("一个算术异常");//抛出异常。

			    //抛出异常时，throw关键字所抛出的是异常类的实例对象，因此throw语句必须使用new关键字来产生对象

			else
				System.out.println(a+"/"+b+"="+a/b); //若没抛出异常，则执行此行。
		}
		catch(ArithmeticException e){
			System.out.println("抛出异常为："+e);
		}
	}
}

2、指定方法抛出异常

如果方法内的程序代码可能会发生异常，且方法内又没有使用任何的代码快来捕捉这些异常时，则必须在声明方法时一并指明所有可能发生的异常，以便让调用此方法的程序得以做好准备来捕捉异常。也就是说，如果方法会抛出异常，则可将处理此异常的try-catch-finally块写在调用此方法的程序代码块内。

如果要由方法抛出异常，则方法必须以下面的语法来声明：

方法名称（参数…） throws 异常类1，异常类2…

范例3

<span style="font-family:Microsoft YaHei;font-size:14px;">class Test{
	//throws在指定方法中不处理异常，再调用此方法的地方处理
	void  add(int a,int b)throws Exception{
		int c;
		c =a/b;
		System.out.println(a+"/"+b+"="+c);
	}
}

public class TestException3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test t = new Test();  // 实例化一Test对象t。
		try {
			t.add(4,0);   //调用Test类中的add（）方法。
		} 
                catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}</span>

如果在类的方法中用throws抛出一个异常，则再调用它的地方，就必须明确地用try-catch来捕捉。

编写自己的异常类

为了各种异常，Java可通过继承的方式编写自己的异常类。因为所有可处理的异常类均继承自Exception类，所以自定义的异常类也必须继承这个类，自己编写异常类的语法如下：

Class 异常类名称 extends Exception
{
	异常类名称（String message)
	{
		 super(message);
	}
}

范例4

class DefaultException extends Exception{
	public DefaultException(String msg){
		//调用Exception类的构造方法，存入异常信息
		super(msg);
	}
}

public class TestException4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try{
			//在这里用throw直接抛出一个DefaultException类的实例对象
			throw new DefaultException("自定义异常！");
		}
		catch(Exception e){
			System.out.println(e);
		}
	}

}

四、异常细节

1、编译期异常和运行期异常的区别?

编译期异常必须要处理的，否则编译不通过

运行期异常可以不处理，也可以处理

2、throw和throws是的区别

throw:

在方法体中,后面跟的是异常对象名,并且只能是一个

throw抛出的是一个异常对象，说明这里肯定有一个异常产生了

throws:

在方法声明上,后面跟的是异常的类名,可以是多个

throws是声明方法有异常，是一种可能性，这个异常并不一定会产生

3、final,finally,finalize的区别?