Java之异常

目录

异常情况

实例

Java的异常类

常用的异常类 

异常处理 

监测可能发生的一种异常

 实例

 监测可能发生的多种异常

实例 

 finally语句

实例

方法的异常处理

实例

实例

手动抛出异常

使用throw语句抛出异常 

实例 

 使用throws语句声明某个方法有可能发生的异常类型

实例 

 throw语句和throws语句的区别

自定义异常类 

使用继承类的方式自定义异常类 

Throwable类常用的方法成员

使用throw语句手动抛出自定义异常类的异常对象 

实例 

---

 

异常情况

异常指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误，常见的异常情况：

• 程序执行所要打开的文件不存在
• 所加载的文件找不到或者格式不对
• 访问数组时，超出数组元素的索引范围
• 数学运算时，除数为0

实例

//Java之异常：指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误
public class Text {
 
	public static void main(String[] args) {
		
		int[] array = new int[10];
		array[10] = 300;  //超出数组边界产生的异常
		
		//发生异常后，若异常没有进行处理就会中断程序的执行
		System.out.println("haozige");
 
	}
}

Java的异常类

Java中所有的异常类都是系统类Throwable的子类。

常用的异常类 

• ArithmeticException：算术运算错误，例如除数除以0
• ArrayIndexOutOfBoundsException：数组下标超出范围
• ArrayStoreException：数组类型与赋值给数组的数据类型不兼容
• ClassCastException：无效的转换
• IllegalArgumentException ：调用方法时的参数不符合规定
• IllegalStateException： 应用程序与环境的状态错误
• IllegalThreadStateException：要求的操作与目前的thread状态不兼容
• NegativeArraySizeException：创建数组的大小是负数
• NumberFormatException：无效的字符串转换成数字格式
• StringIndexOutOfBounds：字符串的索引超出范围
• NoSuchElementException：集合中已无元素但仍读取 

异常处理 

监测可能发生的一种异常

try {

        //需要监测可能发生异常的语句

}

catch (异常类 变量名) {

        //异常发生时的执行语句

}

• 异常类需要和需要检测可能发生异常的语句的异常类型相同 

 实例

//Java之异常：指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误
public class Text {
 
	public static void main(String[] args) {
		
		int[] array = new int[10];
		
		try {  //使用try语句监测异常
			array[10] = 300;  //超出数组边界的异常
		}catch (ArrayIndexOutOfBoundsException e) {  //使用catch语句处理异常
			System.out.println("异常内容：" + e.toString());
		}
		
		//使用try...catch语句处理异常后，程序不会被中止
		System.out.println("haozige");  
	}
}

 监测可能发生的多种异常

try {

        //需要监测可能发生异常的语句

}

catch (异常类 变量名) {

        //异常发生时的执行语句

}

catch (异常类 变量名) {

        //异常发生时的执行语句

 }

.

.

.

catch (异常类 变量名) {

        //异常发生时的执行语句

}

• 当在try语句中监测多种异常时，当第一个被监测到的异常发生时，符号同类型的catch语句就会被执行，而其他catch语句将会被跳过。
• 由于Java的异常类都是继承与Exception类，因此对于不确定异常类型可以使用Exception类来捕获
• 捕获不确定异常的catch语句一定要写在所有catch语句的最后

实例 

数组越界的异常被处理

//Java之异常：指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误
public class Text {
 
	public static void main(String[] args) {
		
		int[] array = new int[10];
		
		try {  //使用try语句监测异常
			
			array[10] = 300;  //超出数组边界的异常
			int tmp = 20/0;  //被除数是0的异常
			int n = Integer.parseInt("你好");  //不确定类型的异常
			
		}catch (ArrayIndexOutOfBoundsException e) {  //使用catch语句处理异常
		
			System.out.println("异常内容：" + e.toString());
			System.out.println("数组越界的异常被处理");
		
		}catch (ArithmeticException e) {
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("被除数为0的异常被处理");
			
		}catch (Exception e) {  //使用Exception类捕获不确定异常
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("不确定类型的异常被处理");
		
		}
		
		//使用try...catch语句处理异常后，程序不会被中止
		System.out.println("haozige");  
	}
}

被除数是0的异常被处理 

//Java之异常：指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误
public class Text {
 
	public static void main(String[] args) {
		
		int[] array = new int[10];
		
		try {  //使用try语句监测异常
			
			array[9] = 300;  //超出数组边界的异常
			int tmp = 20/0;  //被除数是0的异常
			int n = Integer.parseInt("你好");  //不确定类型的异常
			
		}catch (ArrayIndexOutOfBoundsException e) {  //使用catch语句处理异常
		
			System.out.println("异常内容：" + e.toString());
			System.out.println("数组越界的异常被处理");
		
		}catch (ArithmeticException e) {
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("被除数为0的异常被处理");
			
		}catch (Exception e) {  //使用Exception类捕获不确定异常
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("不确定类型的异常被处理");
		
		}
		
		//使用try...catch语句处理异常后，程序不会被中止
		System.out.println("haozige");  
	}
}

不确定类型的异常被处理

//Java之异常：指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误
public class Text {
 
	public static void main(String[] args) {
		
		int[] array = new int[10];
		
		try {  //使用try语句监测异常
			
			array[9] = 300;  //超出数组边界的异常
			int tmp = 20/5;  //被除数是0的异常
			int n = Integer.parseInt("你好");  //不确定类型的异常
			
		}catch (ArrayIndexOutOfBoundsException e) {  //使用catch语句处理异常
		
			System.out.println("异常内容：" + e.toString());
			System.out.println("数组越界的异常被处理");
		
		}catch (ArithmeticException e) {
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("被除数为0的异常被处理");
			
		}catch (Exception e) {  //使用Exception类捕获不确定异常
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("不确定类型的异常被处理");
		
		}
		
		//使用try...catch语句处理异常后，程序不会被中止
		System.out.println("haozige");  
	}
}

 finally语句

try {

        //需要监测可能发生异常的语句

}

catch (异常类 变量名) {

        //异常发生时的执行语句

}

catch (异常类 变量名) {

        //异常发生时的执行语句

}

.

.

.

catch (异常类 变量名) {

        //异常发生时的执行语句

}

finally {

        //不管被监测的语句是否发生异常都会执行的语句

}

 数组越界的异常被处理，finally语句同样执行

实例

//Java之异常：指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误
public class Text {
 
	public static void main(String[] args) {
		
		int[] array = new int[10];
		
		try {  //使用try语句监测异常
			
			array[10] = 300;  //超出数组边界的异常
			int tmp = 20/0;  //被除数是0的异常
			int n = Integer.parseInt("你好");  //不确定类型的异常
			
		}catch (ArrayIndexOutOfBoundsException e) {  //使用catch语句处理异常
		
			System.out.println("异常内容：" + e.toString());
			System.out.println("数组越界的异常被处理");
		
		}catch (ArithmeticException e) {
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("被除数为0的异常被处理");
			
		}catch (Exception e) {  //使用Exception类捕获不确定异常
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("不确定类型的异常被处理");
		
		}finally {
			System.out.println("对于finally语句，不管被监测的语句是否发生异常都会执行的语句");
		}
		
		//使用try...catch语句处理异常后，程序不会被中止
		System.out.println("haozige");  
	}
}

没有异常发生，finally语句同样执行 

//Java之异常：指的是在编译阶段没有语法错误的代码，在程序运行过程中的产生的错误
public class Text {
 
	public static void main(String[] args) {
		
		int[] array = new int[10];
		
		try {  //使用try语句监测异常
			
			array[9] = 300;  //超出数组边界的异常
			int tmp = 20/5;  //被除数是0的异常
			//int n = Integer.parseInt("你好");  //不确定类型的异常
			
		}catch (ArrayIndexOutOfBoundsException e) {  //使用catch语句处理异常
		
			System.out.println("异常内容：" + e.toString());
			System.out.println("数组越界的异常被处理");
		
		}catch (ArithmeticException e) {
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("被除数为0的异常被处理");
			
		}catch (Exception e) {  //使用Exception类捕获不确定异常
			
			System.out.println("异常内容：" + e.toString());
			System.out.println("不确定类型的异常被处理");
		
		}finally {
			System.out.println("对于finally语句，不管被监测的语句是否发生异常都会执行的语句");
		}
		
		//使用try...catch语句处理异常后，程序不会被中止
		System.out.println("haozige");  
	}
}

方法的异常处理

异常发生在所调用的方法中时，方法内有监测和处理异常的语句

实例

public class Text {
	
	static int[] array = new int[10];
	
	static void initArray(){
		try{
			array[10] = 66;
		}catch (ArrayIndexOutOfBoundsException e){
			System.out.println("异常情况：" + e.toString());
		}finally {
			System.out.println("haozige");
		}
	}
	
	public static void main(String[] args) {
		
		initArray();
		
	}
}

 异常发生在所调用的方法中时，方法内没有监测和处理异常的语句，那么系统就会自动到它的上一层方法中寻找符号的catch语句

实例

public class Text {
	
	static int[] array = new int[10];
	
	static void initArray(){
		array[10] = 66;
	}
	
	public static void main(String[] args) {
		try{
			initArray();  //方法内没有处理异常的语句，自动到main方法中寻找符号的catch语句
		}
		catch (ArrayIndexOutOfBoundsException e){
			System.out.println("异常情况：" + e.toString());
		}finally {
			System.out.println("haozige");
		}
	}
}

手动抛出异常

当程序在运行时发生了某种异常，默认情况异常会被JVM拦截并抛出。但有时会因为发生某种错误，导致程序无法继续下去，即异常无法自动抛出，此时需要我们手动抛出异常。

使用throw语句抛出异常 

• 因为所有的异常类都是Throwable的子类，因此使用throw语句抛出异常对象时，这个异常对象必须是Throwable类或者Throwable子类的对象。
• 当使用throw语句抛出异常后，由catch语句捕获所符合的异常，在throw之后的语句将不会执行。

try {

        //需要监测可能发生异常的语句

        throw new  要抛出的异常对象

}

catch (异常类 变量名) {

        //异常发生时的执行语句

}

实例 

public class Text {
	
	static void myPrintf(int age){
		try{
			if(age < 20){
				throw new Exception("未够年龄");
			}
		}catch (Exception e){
			System.out.println("异常内容：" + e.toString());
		}
	}
	
	public static void main(String[] args) {
	
		myPrintf(18);
		
		System.out.println("done!");
	}
}
 

 使用throws语句声明某个方法有可能发生的异常类型

声明xxx方法可能会发生yyy1,yy2,...异常

void xxx() throws yyy1，yy2 ,... {}

实例 

public class Text {
	
	static void myPrintf(int age) throws Exception{  //声明该方法可能会发生Exception异常,该异常不一定会出现
		System.out.println("haozige");
		if (age < 20){
			throw new Exception();
		} 
	}
	
	public static void main(String[] args) {
	
		try {
			myPrintf(10);  //调用该方法时，使用异常类捕获这种可能出现的异常
		} catch (Exception e) {
			System.out.println("jiangxiaoya");
		}
		
		System.out.println("done!");
	}
}
 

 throw语句和throws语句的区别

•  throw语句是手动抛出异常，该异常是一定会发生的，一定要进行异常捕获。
• throws语句是声明某个方法有可能发生某种类型的异常，提醒调用该方法的调用者应该进行这种类型的异常捕获，该异常不一定会发生。

自定义异常类 

对于某些特殊的异常时，Java类库提供的异常类无法满足我们的需求，因此我们需要自定义的异常类来处理这些特殊的异常。

使用继承类的方式自定义异常类 

• 自定义的异常类需要继承Exception类或者Exception类衍生出来的子类。
• Exception类没有定义属于自己的方法，因此可以重写Throwable类（Exception类的父类）的方法来定义自己所需要的异常信息。

Throwable类常用的方法成员

• String getLocalizedMessage(){}：获得异常的局部说明信息 
• String getMessage(){}：获得异常信息
• String toString(){}： 获得包含异常语句的字符串 
• Throwable getCause(){}：获得造成目前异常的异常对象 
• Throwable fillInStackTrace(){}：获得完整堆栈追踪的异常对象          
• void printStackTrace()(){}：显示堆栈追踪 

使用throw语句手动抛出自定义异常类的异常对象 

class 自定义异常类 extends 异常类 {

        //程序语句

} 

.

.

.

throw 自定义异常类对象

.

.

.

实例 

class MyException extends Exception {  //自定义异常类继承Exception类
	
	private String name;
	
	MyException(String name){  //构造方法对数据成员赋值
		this.name = name;
	}
	
	public String toString(){  //对Exception类的toString()进行方法重写
		return "发生了MyException异常";
	}
	
	public String getMessage(){  //对Exception类的getMessage()进行方法重写
		return "怎么回事";
	}
	
	public void myPrintf(){  //自定义异常类MyException的自定义方法
		System.out.println(name);
	}
}
 
 
public class Text {
	
	public static void main(String[] args) {
	
		try{
			throw new MyException("jiangxiaoya");  //手动抛出自定义异常类对象
		}catch (MyException m){
			System.out.println(m.toString());
			System.out.println(m.getMessage());
			m.myPrintf();
		}
		
	}
}