小言_互联网的博客

Java中的异常类

2020-04-01 15:16 246人阅读  评论(0)

Java中的异常类

  1. 任何人所写的程序都有可能出现异常，就像人会生病一样，程序出现异常是一种正常现象。

  2. 程序运行的时候可能出现的一些不正常的现象就是异常【Exception】。【可纠正，可避免】

  3. 程序运行的时候可能出现的一些不可回避的问题就是错误【Error】。【不可纠正】

  4. Java中的异常【Exception】和错误【Error】都是Throwable的子类。

    public class Exception extends Throwable{}

    public class Error extends Throwable{}

    Throwable是Java中异常处理类的顶级类。

  5. 异常【Exception】又有2大类构成

    1. 运行时异常—程序编写的时候没有异常，在运行的时候才会出现的异常
    2. 非运行时异常—我们在编写程序的时候，就已经出现的异常。

6.使用try{}catch(异常类型){}捕获处理异常。

​ 例如：

package com.lin183.test;

public class TestException2 {
	public static void main(String []args) {
		//如何处理异常【Exception】
		//1.使用try()catch(异常模块){处理方法}
		//2.结构
		try {
			int a=10;
			int b=0;
			int c=a/b;
			System.out.println("c==="+c);
		} catch (Exception e) {
			System.out.println("处理异常");
			e.printStackTrace();//打印堆栈异常信息到控制台
		}
	}
}

当我们没有使用try{}catch(){}捕获处理异常的时候，默认Java程序会将这个程序中的异常输出到控制台上。

结构：

try{
	可能出现异常的java代码
}catch(异常类型){
	捕获,处理异常
}
try{}catch(){}捕获处理异常的过程：

1.将可能出现异常的Java代码使用try{}包围，当try{}中的Java代码出现异常，程序就会立刻停止运行，转而执行try{}后面的catch(异常类型){}中的内容，catch块就是书写处理异常的代码。

需要注意事项：

​ 当我们使用try{}catch{}捕获异常的时候，应该告诉catch捕获处理异常的具体异常类型是谁
​ 当我们使用try{}catch(){}捕获处理异常的时候，应该告诉catch捕获处理的具体异常类型是谁
​ 使用try{}catch(参数){}—参数–是一个具体的异常类型–ArithmeticException e
​ 前面我们在使用try{}catch(){}的时候给catch中的参数不是一个具体的异常类型，而是Exception类型。
​ 原因1.所有的具体的异常类型都是Exception类型的子类，我们可以使用Exception类型来代替具体的异常类型，当然我们也可以使用
​ 原因2：在程序还没有运行出现异常之前，我们是不知道这个具体异常类型是什么，所有使用具体异常类型的父类 Excption或者Throwable类型来代替这个具体异常类型。

​ try{}catch(异常类型){}中的catch中的异常类类型，往往是需要一个具体的异常类型。

为什么可以使用Exception或Throwable代替具体异常类型？

Exception是所有具体异常类型的父类，Throwable是Exception的父类。

2.一个try{}后面可以出现多个catch(异常类型){}。当出现多个catch(异常类型){}的时候根据catch中的异常类型按照异常类型的级别从小到大排列。

区分异常类型的级别大小，看异常类型的继承关系

Throwable异常的顶级类，有一个子类Exception，Exception有很多的子类 ArithmeticException 是Exception众多子类中的一个。

代码：

package com.lin183.test;

public class TestException3 {
	public static void main(String []args) {
		try {
			int a=10;
			int b=0;
			int c=a/b;
			System.out.println("c==="+c);
		} catch (ArithmeticException e) {
			System.out.println("具体异常类型，ArithmeticException 除数不能为0的具体1异常类型");
		}catch (Exception e1) {
			System.out.println("具体异常类型");
		}catch (Throwable e2) {
			System.out.println("具体异常类型");
		}	
	}
}

注意：根据catch中的异常类型按照异常类型的级别从小到大排列。区分异常类型的级别大小，看异常类型的继承关系

Throwable异常的顶级类，有一个子类Exception，Exception有很多的子类 ArithmeticException 是Exception众多子类中的一个。

有小到大排列：ArithmeticException Exception Throwable

继承关系：

Public  class  Throwable{}
Public  class  Exception  extends Throwable{}
Public  class  ArithmeticException    extends  Exception  {}

3.finally{}块出现在最后一个catch块的后面，程序有没有异常都会被执行的部分。

package com.lin183.test;

public class TestException3 {
	public static void main(String []args) {
		try {
			int a=10;
			int b=0;
			int c=a/b;
			System.out.println("c==="+c);
		} catch (ArithmeticException e) {
			System.out.println("具体异常类型，ArithmeticException 除数不能为0的具体1异常类型");
		}finally {
			System.out.println("程序无论有没有异常都要处理的部分");
		}
	}
}

4.在方法定义部分，使用throws 异常类型，声明该方法抛出异常。谁调用这个方法谁就要处理这个方法抛出的异常。什么位置调用，什么位置处理。

代码：

TestClass：

package com.lin183.test1;

public class TestClass {
	
	//计算两个数的商
	public int divisor(int num1,int num2) {
		int res=0;
		try {
		res=num1/num2;
		}catch(Exception e) {
			System.out.println("除数不能为0");
		}
		return res;	
	}
}

TestException：

package com.lin183.test1;

public class TestException {

	public static void main(String[] args) {
		TestClass tc= new TestClass();
		int divisor=tc.divisor(10, 0);
		System.out.println("divisor==="+divisor);

	}
}

第二种写法：

TestClass：

package com.lin183.test1;

public class TestClass {
	//计算两个数的商
	//谁调用这个方法谁就要,处理这个方法抛出的异常。什么位置调用，什么位置处理。
	public int divisor(int num1,int num2)throws Exception {
		int res=0;
		res=num1/num2;
		return res;	
	}
}

TestException：

package com.lin183.test1;

public class TestException {

	public static void main(String[] args) {
		TestClass tc= new TestClass();
		int divisor = 0;
		try {
			divisor = tc.divisor(10, 0);
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("divisor==="+divisor);

	}
}

当程序出现异常以后，有两种做法

​ 1.我们自己使用try{}catch(){}捕获处理异常

​ 2.使用throws 声明异常从方法上抛出，谁使用这个带有异常的方法，谁就处理这个方法的

5.手动引发异常throw 异常对象。

6.自定义异常—java没有提供的异常类型，在应用的时候，我们根据自己的需求自己定义产生的一个异常

1.	Throwable是java中异常的顶级类。
2.	在Throwable类下派生出异常【Exception类】和错误【Error类】。
3.	由于错误【Error类】我们无法处理，所我们不学。
4.	异常【Exception类】所有异常类的父类。

通过新建一个java类继承Exception类/Throwable类，就可以做一个自定义异常。

MyArray：

package com.lin183.test2;

public class MyArray {
	//定义一个变量，保存创建数组空间大小
	private int size=0;
	//通过本类构造方法，接收一个数组大小
	public MyArray(int len) throws MyException{
		this.size=len;
		cheack();
	}
	/**
	 * 创建整数数组的方法
	 * @return
	 */
	public void cheack() throws MyException{
		if (this.size<=0) {
			//应该提醒用户数字不能为负数
			//手动引发异常throw 异常对象
			//使用一下我们自己定义的异常类型
			throw new MyException("数组大小不能为负数");
		}
	}
	
	public int[] creatIntArray() {
		int array[]=new int[size];
		return array;
	}
}

MyException：

package com.lin183.test2;
//继承了exception/throwable的java类才是一个自定义异常类
public class MyException extends Exception{
	/**
	 * 创建自定义的构造方法
	 * 构造方法的参数时异常提醒信息
	 */
	public MyException(String msg){
		super(msg);
	}
}

TestClass：

package com.lin183.test2;

public class TestClass {

	public static void main(String[] args) {
		MyArray myarray=null;
		try {
			myarray = new MyArray(-5);
		} catch (MyException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		int array[]=myarray.creatIntArray();
	}
}

运行结果：

思考：

  1. 区分Exception和Error？？？

    1. Error（错误）表示系统级的错误和程序不必处理的异常，是java运行环境中的内部错误或者硬件问题。
    2. Exception（违例）表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。
    3. Exc[外链图片转存失败,源站可能有防盗在这里插入!链机制,建描述]议将图片上https://传(imblogsdnimg.cn/20200304223002355.png?x-oss-process=image/watermark,type_PmFcZZ6uD3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzUxMTc0NQ==,size_16,color_FFFFFF,t_70)https://img-blogG9nLmNzZG4ubmV0L3dlaXhpbl80MzUxMTc0NQ==,size_16,color_FFFFFF,t_70)]eption又分为运行时异常，受检查异常。运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。 受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。

  2. 运行时异常与非运行时异常的区别？

    1. Throwable 是所有 Java 程序中错误处理的父类 ，有两种资类： Error 和 Exception 。 Error ：表示由 JVM 所侦测到的无法预期的错误，由于这是属于 JVM 层次的严重错误 ，导致 JVM 无法继续执行，因此，这是不可捕捉到的，无法采取任何恢复的操作，顶多只能显示错误信息。Exception ：表示可恢复的例外，这是可捕捉到的。

  3. try{}catch(){}异常处理的过程.

  4. try{
		//需要被检查的异常
}catch（异常类  变量）//该变量用于接收发生的异常
{
//处理异常的代码
}
	finally{
	//一定会被执行的代码。
}

  5. finally/throws/throw关键字

  6. finally 关键字用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。finally 代码块出现在 catch 代码块最后

  7. throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以紧跟一个或多个异常类。

  8. throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以紧跟一个或多个异常类。

注意：

  • catch 不能独立于 try 存在。

  • 在 try/catch 后面添加 finally 块并非强制性要求的。

  • try 代码后不能既没 catch 块也没 finally 块。

    1. finally 关键字用来创建在 try 代码块后面执行的代码块。无论是否发生异常，finally 代码块中的代码总会被执行。在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。finally 代码块出现在 catch 代码块最后
    2. throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以紧跟一个或多个异常类。
    3. throws用于在方法签名中声明抛出一个或多个异常类，throws关键字后可以紧跟一个或多个异常类。

注意：

  • catch 不能独立于 try 存在。
  • 在 try/catch 后面添加 finally 块并非强制性要求的。
  • try 代码后不能既没 catch 块也没 finally 块。
  • try, catch, finally 块之间不能添加任何代码

转载：https://blog.csdn.net/weixin_43511745/article/details/104664319
查看评论
* 以上用户言论只代表其个人观点，不代表本网站的观点或立场