关于Java异常-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_59568478/article/details/118493993

这篇博客探讨了Java中的异常处理机制，包括try-catch-finally块的使用，异常堆叠，以及如何自定义异常。它强调了在方法中声明可能抛出的异常的重要性，并解释了如何在子类中覆盖父类方法时处理异常。还提到了构造器中的异常处理，以及如何匹配和捕获不同类型的异常。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

如果某句出了异常，后面的语句将不会再被执行

package exception;
import java.util.*;
public class ArrayIndex {

	public static void main(String[] args) {
		int[] a=new int[10];
		int idx;
		Scanner in=new Scanner(System.in);
		idx=in.nextInt();
		try {
		a[idx]=10;//这就属于异常
		System.out.println("hello");
	}catch(ArrayIndexOutOfBoundsException e) {
		System.out.println("catch");//异常处理，catch以后继续执行后面的语句
	}
	}
}

catch可以堆叠，按照书写位置找，找到第一个catch后面就不找了
找到合适位置处理异常

package exception;
import java.util.*;
public class ArrayIndex {
    public static void f() {
    	int[] a=new int[10];
    	a[10]=10;
    	System.out.println("hello");
    }
	public static void main(String[] args) {
		try{
			f();
		}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("3");
		}
		System.out.println("main");//3 main
	}
}

在这里插入图片描述

package exception;
import java.util.*;
public class ArrayIndex {
    public static void g() {
    	f();
    }
    public static void f() {
    	int[] a=new int[10];
    	a[10]=10;
    	System.out.println("hello");
    }
    public static void h() {
    	int i=10;
    	if(i<100) {
    		g();
    	}
    }
    public static void k() {
    	try {
    		h();
    	}catch(NullPointerException e){
    		System.out.println("1");
    	}
    }
    public static void main(String[] args) {
    	try{
    		k();
    	}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("3");
		}
    	}
    	
}

捕捉到异常后：

package exception;
import java.util.*;
public class ArrayIndex {
    public static void g() {
    	f();
    }
    public static void f() {
    	int[] a=new int[10];
    	a[10]=10;
    	System.out.println("hello");
    }
    public static void h() {
    	int i=10;
    	if(i<100) {
    		g();
    	}
    }
    public static void k() {
    	try {
    		h();
    	}catch(NullPointerException e){
    		System.out.println("1");
    	}
    }
    public static void main(String[] args) {
    	try{
    		k();
    	}catch(ArrayIndexOutOfBoundsException e) {
			System.out.println("3");
			System.out.println(e.getMessage());//捕捉到异常时放在异常对象里的值
			System.out.println(e);
			e.printStackTrace();//所有发生异常的位置从哪一个开始有问题了
		}
    	}
    	
}

抛出就是throw e；抛出这个异常
BL指的是业务逻辑，后面是运行机制
异常的声明
如果你的函数可能抛出异常，就必须在函数头部加以声明
你可以声明但是不真的抛出异常

package exception;
import java.util.*;
class OpenException extends Throwable{
	
}//这里的的东西可以抛
public class ArrayIndex {
	public static int open() {
		return -1;
	}
	public static void readFile() throws OpenException{//表示这个函数是会抛出异常的
		if(open()==-1) {
			throw new OpenException(); //int类型不能被抛，只有throwable的子类可以抛,不能直接抛新建实例，
		}
	}
    public static void main(String[] args) {
    	try {
			readFile();
		} catch (OpenException e) {
			e.printStackTrace();
		}
    }
}

任何继承了Throwable类的对象
Exception类继承了Throwable

package exception;
import java.util.*;
class OpenException extends Throwable{
	
}//这里的的东西可以抛
public class ArrayIndex {
	public static int open() {
		return -1;
	}
	public static void readFile() throws OpenException{//表示这个函数是会抛出异常的
		if(open()==-1) {
			throw new OpenException(); //int类型不能被抛，只有throwable的子类可以抛,不能直接抛新建实例，
		}
	}
    public static void main(String[] args) {
    	try {
			readFile();
		} catch (OpenException e) {
			e.printStackTrace();
		}
    }
}

catch匹配异常的时候，抛出子类异常会被捕捉父类异常的catch给捉到，所以两个连catch一个抓父类再抓子类就会报错
catch（Exception e）{//任何异常都会被捕捉，包括系统异常
}
系统运行异常是不需要声明的，比如数组越界，但是如果没有适当的机制来捕捉，最后就会导致程序终止

异常遇到继承
如果调用一个会抛出异常的函数：
把函数的调用放在try块中，并设置catch捕捉所有可能抛出的异常或声明自己会抛出无法处理的异常
当要覆盖一个函数时，子类不能声明抛出比父类的版本更多的异常
在子类构造函数中，必须声明父类可能抛出的全部异常

package exception;
import java.util.*;
class OpenException extends Exception{
	
}//这里的的东西可以抛
class CloseException extends OpenException{
	
}
class NewException extends Exception{
	
}
public class ArrayIndex {
	public void f() throws OpenException{
		
	}
	public static void main(String[] args) {
		
	}
}
class NewClass extends ArrayIndex{
	public void f() throws CloseException{//throws CloseException是可以的，因为是子类，NewException不行，因为超出父类可抛出类型范围了
	}
	public static void main(String[] args) {
		ArrayIndex p=new NewClass();//指的是子类的东西
		try {
			p.f();
		} catch (OpenException e) {
			e.printStackTrace();
		}
		
	}
}

构造器异常

package exception;
import java.util.*;
class OpenException extends Exception{
	
}//这里的的东西可以抛
class CloseException extends OpenException{
	
}
class NewException extends Exception{
	
}
public class ArrayIndex {
	public ArrayIndex() throws OpenException{
		
	}
	public void f() throws OpenException{
		
	}
	public static void main(String[] args) {
		
	}
}
class NewClass extends ArrayIndex{
	public NewClass() throws OpenException{//这里父类有可能抛出异常，所以在这里调用父类时必须事先声明可能会抛出的所有异常
		//构造函数可以声明更多的异常，但是成员函数不行，因为可能拿子类对象当做父类对象看待
	}
	public void f() throws CloseException{//throws CloseException是可以的，因为是子类，NewException不行，因为超出父类可抛出类型范围了
	}
	public static void main(String[] args) {
		//指的是子类的东西
		try {
			ArrayIndex p=new NewClass();//构造器也要移位置
			p.f();
		} catch (OpenException e) {
			e.printStackTrace();
		}
		
	}
}