java异常分类,异常处理,面试中常见异常问题!

javaSE 同时被 2 个专栏收录
37 篇文章 0 订阅

什么是异常?
程序运行过程中产生的不正常的情况统称为异常!
Throwable 类是 Java 语言中所有错误或异常的超类。提供了错误堆栈实现等一系列方法。 有两个直接子类:Error & Exception

程序错误一般分为三种:

1.编译错误;2.运行时错误;3.逻辑错误。

(1)编译错误是因为程序没有遵循语法规则,编译程序能够自己发现并且提示我们错误的原因和位置,这个也是我们在刚接触编程语言最常遇到的问题。

(2)运行时错误是因为程序在执行时,运行环境发现了不能执行的操作。

(3)逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误,而异常处理就是对这些错误进行处理和控制。

先说一下java异常体系结构图吧:
.java异常类结构体系图
两个子类区别:

  1. Error: 程序不应该捕捉的错误,应该交由JVM来处理。一般可能指非常重大的错误。这个错误我们一般获取不到,也无法处理!

  2. Exception:程序中应该要捕获的错误。这个异常类及它的子类是我们需要学习获取要处理的。

    (1)RuntimeException:运行时异常,也叫未检查异常,是Exception的子类,但不需捕捉的异常超类,但是实际发生异常时,还是会导致程序停止运行的的,只是编译时没有报错而已。比如除数为零,数组空指针等等,这些都是在运行之后才会报错。此类异常,可以处理也可以不处理,并且可以避免。

    (2)在Exception的所有子类中 除了RuntimeException类和它的子类,其他类都叫做非运行时异常,或者叫已检查异常,通常被定义为Checked类,是必须要处理可能出现的异常,否则编译就报错了。Checked类主要包含:IO类和SQL类的异常情况,这些在使用时经常要先处理异常(使用throws或try catch捕获)。

java几种常见的异常:
运行时异常:
1,java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2,ArithmeticException 算术错误情形,如以零作除数,算术条件异常。
3 java.lang.SecurityException 安全性异常
4,IllegalArgumentException 方法接收到非法参数,非法参数异常!
5,java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
6,java.lang.NegativeArraySizeException 数组长度为负异常
7 java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。
8 java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
9,java.lang.NumberFormatException(数字格式转换异常)
10,java.lang.ClassCastException(强制类型转换异常)

IOException
1, IOException 操作输入流和输出流时可能出现的异常
2, EOFException 文件已结束异常
3, FileNotFoundException 文件未找到异常

异常的产生:

自动产生:当程序遇到错误代码,会产生异常,程序终止
手动产生:throw new 异常类名();
throw必须定义在在方法体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。

下面看一个手动抛出异常的例子:

package prac;
public class t2 {
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		m1();
	}

	public static void m1() throws Exception {
		System.out.println("m1----------start");
		m2();
		// 手动抛出受查异常
		throw new Exception();
		//System.out.println("m1----------end");
	}

	public static void m2() {
		System.out.println("m2----------start");
		// 手动抛出运行时异常,需要携带信息“程序因为异常而终止”
		throw new RuntimeException("程序因为异常而终止");
		//System.out.println("m2----------end");
	}
}
程序运行结果为:
m1----------start
m2----------start
Exception in thread "main" java.lang.RuntimeException: 程序因为异常而终止
	at prac.t2.m2(t2.java:31)
	at prac.t2.m1(t2.java:21)
	at prac.t2.main(t2.java:16)

异常的处理:

异常的处理分为消极的处理(自己处理不了,就往调用它的地方上抛throws,异常没有解决,只是抛出)和积极处理(异常捕获,捕捉异常通过try-catch语句或者try-catch-finally语句实现)

消极的处理:
语法:public void m1() throws 异常类名1,异常类名2{}
特点:相当于推卸责任,最终问题依然无法得到解决。
允许编译通过。
当上抛的异常为非运行(已检查)时异常时,调用此方法的调用者必须处理。
当上抛的异常为运行(未检查)时异常时,可以处理可以不处理。

积极的处理:(异常捕获)
将异常直接捕获,并且做出处理
语法:

try{
	  //异常代码
	}catch(异常类名 引用名){  

		//当异常产生执行的代码
	}

try 后的catch代码块 只能匹配成功一个
catch后声明的异常为父类时,它能够捕捉的异常为它本身+所有子类异常(多态的体现)
注意:catch代码块捕获异常时,子类异常必须定义在父类异常前面,否则会编译出错

finally代码块:一定会执行此代码块中的代码,常用来关闭资源,

	try{
	
	}catch(){
	
	}finally{
		//无论是否产生异常,一定会去执行的代码
	}
注意:finally代码块中不要定义return语句

下面一个程序详细介绍异常的处理:

package work;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Scanner;

/**
 * @author 超伟
 * @date 2019年5月13日  
 * @version 1.0.0  
 */
public class t4 {
	public static void main(String[] args) {
		System.out.println("main1");
		int n;
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		ma(n);
		System.out.println("main2");
	}
	public static void ma(int n){
		try {
			System.out.println("m1");
			mb(n);
			System.out.println("m2");
		} catch (EOFException e) {
			//e.printStackTrace();
			System.out.println("EOFException    ");
		} catch (IOException e) {
			System.out.println("IOException e111");
		}catch (SQLException e) {
			System.out.println("SQLException");
		}catch (Exception e) {
			System.out.println("Exception");
		}finally{
			System.out.println("in finally");
		}
	}
	
	public static void mb(int n) throws Exception {
		System.out.println("mb1");
		if (n==1) {
			throw new EOFException();
		}
		if (n==2) {
			throw new FileNotFoundException();
		}
		if (n==3) {
			throw new SQLException();
		}
		if (n==4) {
			throw new NullPointerException();
		}
		System.out.println("mb2");
	}	
}
程序运行结果为:
main1
1
m1
mb1
EOFException    
in finally
main2

throw和throws的区别

这只是有点相似的关键字,并没有任何关联,要学会区分。

throw是用在方法体里面的,一般是放在判断情况的后面,手动抛出异常。

throws只能用在需要捕获异常的方法的方法名的括号后面使用。

自定义异常:

为什么要自定义异常?
当Java内置的异常都不能明确的说明异常情况的时候,需要创建自己的异常。

自定义一个异常类,需要继承于Exception或者其子类。
若想要这个异常类为运行时异常,需继承于RuntimeException或者其子类。
一般定义为运行时异常

自定义的异常类需要至少无参有参两个构造方法
例如:

package work;
import java.io.EOFException;
import java.util.Scanner;
public class t5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		try {
			m(n);
			
		} catch (MyException1 e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println(e.getMessage());
		}catch (MyException2 e) {
			// TODO: handle exception
			e.printStackTrace();
			System.out.println(e.getMessage());
		}	
	}
	
	public static void m(int n) throws MyException1{
		if (n==1) {
			throw new MyException1("我自己定义的非运行时异常");
		}
		else {
			throw new MyException2("这是我定义的一个运行时异常!!!");
		}
	}
}
//自定义异常
//已检查异常,非运行时异常
class MyException1 extends EOFException{
	public MyException1() {
		super();
	}

	public MyException1(String s) {
		super(s);
	}
}
//未检查异常
//运行时异常
class MyException2 extends RuntimeException{
	public MyException2() {
	}
	public MyException2(String message) {
		super(message);
	}
}

方法覆盖,在继承中的异常的提现:
方法覆盖需要满足的3个条件
1.返回值类型 方法名 参数列表完全一致
2.访问修饰符相同或更宽
3.子类中方法不能抛出比父类更多、更宽的异常

package work;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;

/**
 * @author 超伟
 * @date 2019年5月13日  
 * @version 1.0.0  
 */
public class t8 {
	/**
	 * @param args 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
}
class Super{
	public void ma() throws IOException{
		
	}
}
interface IA{
	void mb();
}
class MySub extends Super implements IA{
	//父类抛出一个非运行时异常,子类可以抛出一个或者多个父类抛出的异常的子类异常
	/*public void ma() throws IOException,FileNotFoundException,EOFException{
	}*/
	//父类抛出一个非运行时异常,子类可以抛出一个或者多个运行时异常
	public void ma() throws SecurityException,ClassCastException{
	}
	public void mb() {
	}
}

Java异常处理的原则和技巧
1,避免过大的try块。不要把不会出现异常的代码放到try块里面,尽量保持一个try块对应一个或多个异常。
2,细化异常的类型。不要不管什么类型的异常都写成Excetpion。
3,catch块尽量保持一个块捕获一类异常。不要忽略捕获的异常,捕获到后要么处理,要么转译,要么重新抛出新类型的异常。
4,不要把自己能处理的异常抛给别人。
5,不要用try…catch参与控制程序流程。异常控制的根本目的是处理程序的非正常情况。

所以像那些可以预料的错误,尽量在执行之前就做好相应的处理,

比如除数为零或空指针问题,要做事前判断再运行程序。

final, finally, finalize 的区别。

final 用于声明属性,方法和类,分别表示属性不可变,方法不可覆盖,类不可继承。内部类要访问局部变量,局部变量必须定义成 final 类型

finally 是异常处理语句结构的一部分,表示总是执行。

finalize 是 Object 类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,可以覆盖此方法提供垃圾收集时的其他资源回收,例如关闭文件等。JVM 不保证此方法总被调用

运行时异常与一般异常有何异同?

异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运行错误。java 编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。

error 和 exception 有什么区别?

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。
exception 表示一种设计或实现问题。也就是说,它表示如果程序运行正常,从不会发生的情况。

Java 中的异常处理机制的简单原理和应用。

异常是指 java 程序运行时(非编译)所发生的非正常情况或错误,与现实生活中的事件很相似,现实生活中的事件可以包含事件发生的时间、地点、人物、情节等信息,可以用一个对象来表示,Java 使用面向对象的方式来处理异常,它把程序中发生的每个异常也都分别封装到一个对象来表示的,该对象中包含有异常的信息。

Java 对异常进行了分类,不同类型的异常分别用不同的 Java 类表示,所有异常的根类为 java.lang.Throwable,
Throwable 下面又派生了两个子类:Error 和 Exception,Error 表示应用程序本身无法克服和恢复的一种严重问
题,程序只有死的份了,例如,说内存溢出和线程死锁等系统问题。Exception 表示程序还能够克服和恢复的问题,其中又分为系统异常和普通异常,系统异常是软件本身缺陷所导致的问题,也就是软件开发人员考虑不周所导致的问题,软件使用者无法克服和恢复这种问题,但在这种问题下还可以让软件系统继续运行或者让软件死掉,例如,数组脚本越界 ( ArrayIndexOutOfBoundsException ) , 空 指 针 异 常 ( NullPointerException ) 、 类 转 换 异 常(ClassCastException);普通异常是运行环境的变化或异常所导致的问题,是用户能够克服的问题,例如,网络断线,硬盘空间不够,发生这样的异常后,程序不应该死掉。

java 为系统异常和普通异常提供了不同的解决方案,编译器强制普通异常必须 try…catch 处理或用 throws 声明继
续抛给上层调用方法处理,所以普通异常也称为 checked 异常,而系统异常可以处理也可以不处理,所以,编译器不强制用 try…catch 处理或用 throws 声明,所以系统异常也称为 unchecked 异常。

就按照三个级别去思考:虚拟机必须宕机(就是死机)的错误,程序可以死掉也可以不死掉的错误,程序
不应该死掉的错误;

JAVA 语言如何进行异常处理,关键字:throws,throw,try,catch,finally 分别代表什么意义?

throws 是获取异常
throw 是抛出异常
try 是将会发生异常的语句括起来,从而进行异常的处理,也可以在 try 块中抛出新的异常
catch 是如果有异常就会执行他里面的语句
finally 不论是否有异常都会进行执行的语句

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值