Java--异常总结_java异常交由上一级-CSDN博客

本文链接：https://blog.csdn.net/afu10086/article/details/11910227

java将所有的错误封装成为一个对象，其根本父类为Throwable

Throwable
--Error:指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退出，
   因为已经失去了运行所必须的物理环境，一般不编译特定的代码进行处理
--Exception:要用针对性的处理方式进行处理
  --RunntimeException:运行时异常，可以不进行处理
       这类异常可以不捕获或声明，编译可以通过
  --非RunntimeException:要进行处理，这类异常要捕获或是声明，不然编译无法通过

常用方法：
  getMessage()：获取异常信息，返回字符串
  toString()：获取异常类名和异常信息，返回字符串
  printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置
  printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅

1.异常的处理方式：
第一种方式：捕获
  (1).后面可以跟多个catch异常对象，但异常对象应该按由子类到父类的方式排列
   如果父类异常排在子类的前面，那么后面的子类异常会执行不到

  try{
   可能出现异常的代码
  }catch(异常类型,变量){
   异常处理方式
  }

  (2).finally是一定会执行的语句，一般用来关闭资源

  try{
   可能出现异常的代码
  }catch(异常类型,变量){
   异常处理方式
  }finally{
   一定会执行的语句
  }

  (3).其实这种方式并不能捕获异常，因为没有catch进行处理，当try中出现异常时，程序还是
   会直接抛出异常给上级(指的是运行时异常，非运行时异常编译不通过)

  try{
   可能会出现异常的代码
  }finally{
   一定会执行的语句
  }

第二种方式：声明
  在函数内部直接将异常抛出，并在函数上声明这个异常，将异常交由上一级处理

  throw与throws区别
  throw:用在函数内部，在函数内部抛出异常，后面跟的是异常对象
  throws:用在函数上，后面跟的是异常类，并且可以跟多个异常类，中间有逗号分开

//第一种方式：捕获异常
public class ExceptionTest{
	public static void main(String[] args){
		div(4,7);
		System.out.println("main code");
	}
	
	public static void div(int a,int b){
		//捕获异常，当出现异常时，语句直接跳转到catch中进行异常的处理，try中出现异常的后面的语句就不会执行了
		try{
				int temp=a/b;
				int[] num=new int[a];
				System.out.println("temp="+temp);
				System.out.println(num[a]);
			}catch(ArithmeticException e){
				e.printStackTrace();
				//try后可以跟多个catch，应按照子类到父类的排列顺序，
				//如果try中出现了catch中所有的异常，那么程序会直接抛出异常给上一级
				//catch语句中不能再嵌套try--catch
			}catch(ArrayIndexOutOfBoundsException e){
				e.printStackTrace();
				//finally中执行的一般是关闭资源的操作
			}finally{
				System.out.println("一定会执行的语句");
			}
	}
}

//第二种方式：声明异常
public class ExceptionTest{
	public static void main(String[] args) throws Exception{
		//调用者可以进行try或在函数上声明，如果进行了try那后面的语句还会执行，只是声明那后面的语句就不会执行了
		div(4,0);
		System.out.println("main code");
	}
	//在函数上声明异常，将异常交由上一级处理
	public static void div(int a,int b) throws Exception{
		int temp=a/b;
		System.out.println("temp="+temp);
	}
}

2.自定义异常类：必须是自定义类继承Exception类体系
因为异常类和异常对象都要具有可抛性，这个可抛性是Throwable这个体系中独有特点，所有自定义异常类要继承于
这个体系，也只有这个体系中的类才可以被throw和throws所操作

//如果不想对自定义的异常类进行处理，可以让自定义类继承RuntimeException
class MyException extends Exception {
		MyException(String message){
		super(message);
	}
}
public class ExceptionTest{
	public static void main(String[] args) throws MyException{
		show(-1);
	}
	public static void show(int a) throws MyException{
		if(a<0)
		//抛出自定义异常类
			throw new MyException("角标为负数");
		int[] num=new int[a];
		System.out.println("num="+num[a]);
	}
}

3.异常类在子父类中的体现：
子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常,如果子类发生了异常，只能进行try

class MyException extends Exception {
		MyException(String message){
		super(message);
	}
}
class Father{
	String str="lidaofu";
	char[] name=str.toCharArray();
	//父类抛出的异常
	public void show(int index) throws ArrayIndexOutOfBoundsException{
		System.out.println("name["+index+"]"+name[index]);
	}
}
class Son extends Father{
	int age=0;
	//当子类继承父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类
	//如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常，只能通过try--catch解决
	public void show(int index) throws ArrayIndexOutOfBoundsException{
		System.out.println("name["+index+"]="+name[index]);
		try{
			if(age==0){
				throw new MyException("除数为零啦");
				//当throw单独存在时，后面不能跟语句，因为执行不到
				//System.out.println(age);编译失败，这句话是执行不到的
				}
			int temp=index/age;
			System.out.println("temp="+temp);
		}catch(MyException e){
			e.printStackTrace();
		}
	}
}
public class ExceptionTest{
	public static void main(String[] args) throws MyException{
		Son s=new Son();
		s.show(3);
		System.out.println("main code");
	}	
}

4.finally的执行时间问题
  finally语句是在return语句之后，跳转到上一级程序之前执行(即return语句中间执行)
  finally中的语句一定会执行，是建立在对应的try得到执行情况下，如果程序在try语句之前就发生了
  异常或就已经结束，那finally中的语句是不会执行的
  finally在一种情况下不会执行，System.exit(0):程序停止运行，退出虚拟机

public class ExceptionTest{
	public static void main(String[] args){
		System.out.println(test());
	}
	public static String test(){  
     try{  
			System.out .println("try block");  
			return test1 ();  
		} finally {  
			System.out .println("finally block");
			//return "finally"; 如果finally中有返回值，那么finally返回值就会替换掉上一级方法中的返回值
			//					这一句如果执行，那程序上一级方法中的after return 就会被finally所替换
		}  
	}  
	public static String test1(){  
		System.out.println("return statement");  
		return "after return";  
	}
}

程序结果为：
  try block
  return statement
  finally block
  after return

原因分析：
   1.try语句块，return test1()，则调用test1方法
   2.test1()执行后返回"after return"，返回值"after return"保存在一个临时区域里
   3.执行finally语句块。若finally语句有返回值，则此返回值将替换掉临时区域的返回值
   4.将临时区域的返回值送到上一级方法中。

public class ExceptionTest{
	public static void main(String[] args){
		int a=5;
		int[] arr=new int[5];
		//return 0;要想让方法停止运行可以return或throw个异常
		int i=a/0;
		try{
			System.out.println(arr[6]);
		}catch(ArrayIndexOutOfBoundsException e){
			System.out.println(e.getMessage());
			System.out.println("角标越界");
		//这里的finally语句是不会执行的，因为在try语句之前程序就已经停止运行了
		}finally{
			System.out.println("finally");
		}
	}
}