Java基础之Java异常处理机制，

来源： javaer 分享于 2023-09-05 点击 15751 次点评：124

Java基础之Java异常处理机制，

Java异常处理

查看一下Java的API:

java.lang

Class Throwable

java.lang.Object
- java.lang.Throwable

All Implemented Interfaces:
Serializable
Direct Known Subclasses:
Error, Exception

从这里不难看出

Exception:是处理编译级别错误； Error:是JVM处理级别错误

异常：是导致程序中断运行的一种指令流，如果不对异常进行正确的处理，则可能导致程序的中断执行，造成不必要的损失，所以在程序的设计中必须考虑各种异常的发生，并正确的做好相应的处理，这样才能保证程序的正常执行。
处理异常的几个关键字： throw
throws
try { //异常出现点 }catch(Exception e){ //细粒度的异常放在前面，粗粒度异常放在后面 //捕获遗产处理 }catch(Exception){ }finally{ //不管是否有异常，都执行。 }
Demo1

public class ExceptionDemo06{
	public static void main(String args[]){
		System.out.println("********** 计算开始 ***********") ;
		int i = 0 ;		// 定义整型变量
		int j = 0 ;			// 定义整型变量
		try{
			String str1 = args[0] ;		// 接收第一个参数
			String str2 = args[1] ;		// 接收第二个参数
			i = Integer.parseInt(str1) ;	// 将第一个参数由字符串变为整型
			j = Integer.parseInt(str2) ;	// 将第二个参数由字符串变为整型
			int temp = i / j ;	// 此处产生了异常
			System.out.println("两个数字相除的结果：" + temp) ;
			System.out.println("----------------------------") ;
		}catch(ArithmeticException e){	// 捕获算术异常
			// System.out.println("算术异常：" + e) ;
			e.printStackTrace() ;
		}catch(NumberFormatException e){	// 捕获数字转换异常
			System.out.println("数字转换异常：" + e);
		}catch(ArrayIndexOutOfBoundsException e){	// 捕获数组越界异常
			System.out.println("数组越界异常：" + e) ;
		}catch(Exception e){
			System.out.println("其他异常：" + e) ;
		}
		System.out.println("********** 计算结束 ***********") ;
	}
};

当所有的异常处理的方式是一样得时候就可以使用以上的形式，直接使用Exception进行捕获，当然，在一个
比较细致的开发中是不建议这样使用的，所有的异常最好分别捕获。 问题： 既然，捕获Exception是最方便的，那么直接捕获Throwable可以不可以？首先，这样的做法是可以的，但是正常的开发人员是不会这样去做的，因为在程序的try中只会抛出Exception的子类部分内容，而Throwable中还有Error。所以，最高就是Exception.

throws 与throw

throws : 在定义异常时，他会把异常抛出给调用的一方处理，自己不做处理；

class Math{
<span >	</span>public int div(int i,int j) throws Exception{<span >	</span>// 定义除法操作，如果有异常，则交给被调用处处理
<span >		</span>int temp = i / j ;<span >	</span>// 计算，但是此处有可能出现异常
<span >		</span>return temp ;
<span >	</span>}
};
public class ThrowsDemo01{
<span >	</span>public static void main(String args[]){
<span >		</span>Math m = new Math() ;<span >		</span>// 实例化Math类对象
<span >		</span>try{
<span >			</span>System.out.println("除法操作：" + m.div(10,2)) ;
<span >		</span>}catch(Exception e){
<span >			</span>e.printStackTrace() ;<span >	</span>// 打印异常
<span >		</span>}
<span >	</span>}
};

如果在主方法中不处理任何的异常了，而是交给最大的头，JAVA中的最大的头JVM处理，所以，如果在主方法中使用throws关键字，则表示一切的异常都交给JVM处理。

throw: 它是可以直接抛出一个异常。抛出的异常可以直接抛出异常的实例化对象即可。

public class ThrowDemo01{
	public static void main(String args[]){
		try{
			throw new Exception("自己抛着玩的。") ;	// 抛出异常的实例化对象
		}catch(Exception e){
			System.out.println(e) ;
		}
	}
};

下面看看异常联合使用的案例：这是使用最多的方式；

class Math{
	public int div(int i,int j) throws Exception{	// 定义除法操作，如果有异常，则交给被调用处处理
		System.out.println("***** 计算开始 *****") ;
		int temp = 0 ;	// 定义局部变量
		try{
			temp = i / j ;	// 计算，但是此处有可能出现异常
		}catch(Exception e){
			throw e ;
		}finally{	// 不管是否有异常，都要执行统一出口
			System.out.println("***** 计算结束 *****") ;
		}
		return temp ;
	}
};
public class ThrowDemo02{
	public static void main(String args[]){
		Math m = new Math() ;
		try{
			System.out.println("除法操作：" + m.div(10,0)) ;
		}catch(Exception e){
			System.out.println("异常产生：" + e) ;
		}
	}
};

Exception:存在他的构造方法,可以抛出他的实例化对象；

Exception 与 RuntimeException

我们来看看这段代码：

public class RuntimeExceptionDemo01{
	public static void main(String args[]){
		String str = "123" ;	// 定义字符串，全部由数字组成
		int temp = Integer.parseInt(str) ; // 将字符串变为int类型
		System.out.println(temp * temp) ;	// 计算乘方
	}
};

转型的过程中，发生了异常抛出，当上层代码却没有try{ }cath(){ } 捕获异常？原因是NumberFormatException是RuntimeException的子类。

java.lang.Object
- java.lang.Throwable
- - java.lang.Exception
  - - java.lang.RuntimeException
    - - java.lang.IllegalArgumentException
      - java.lang.NumberFormatException

public static int parseInt(String s)
                    throws NumberFormatException

在JAVA异常处理机制中，用Exception必须使用try .....catch 进行处理。如果抛出的RuntimeException的类型，则不是必须使用trt......catch().., 他一旦发生异常，则由JVM处理；

自定义异常

class MyException extends Exception{	// 自定义异常类，继承Exception类
	public MyException(String msg){
		super(msg) ;	// 调用Exception类中有一个参数的构造方法，传递错误信息
	}
};
public class DefaultException{	
	public static void main(String args[]){
		try{
			throw new MyException("自定义异常。") ;	 // 抛出异常
		}catch(Exception e){
			System.out.println(e) ;
		}
	}
}

了解断言的作用

public class Test{
	public static void main(String args[]){
		int x[] = {1,2,3} ;	// 定义数组，长度为3
		assert x.length==0 : "数组长度不为0" ;	// 此处断言数组的长度为0
	}
};

Java基础之Java异常处理机制，