Java异常处理详解-优快云博客

本文深入讲解Java中的异常处理机制，包括异常的概念、分类、处理方式及自定义异常的实现方法。探讨了如何通过try-catch-finally语句有效管理程序运行中的错误情况。

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

/*
异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事物，也可以通过
java的类的形式进行描述，并封装成对象。其实就是java对不
正常情况进行描述后的对象体现。

对于问题的划分：两种：一种是严重的问题，一种非严重的问题

对于严重的，java通过Error类进行描述。
对于非严重的，java通过Excetption进行描述。

对于非严重的java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。
比如：不正常情况的信息，引发的原因等

Throwable
   |---Error

   |---Exception

2，异常的处理
java提供了特有的语句进行处理
try
{
需要被检测的代码
}
catch(异常类变量)
{
处理异常的代码;（处理方式）
}
finally
{
一定会执行的语句；
}

3,对捕获到的异常进行常见方法操作。
String getMessage()：获取异常信息

对多异常的处理：
1，声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
2,对方声明几个异常，就对应几个catch块。不要定义多余的catch块
如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

建议：在进行catch处理时，catch中一定要定义具体处理方式。
不要简单定义一句e.printStackTrace();
也不要简单的就书写一条输出语句。
*/

class Demo
{
//在功能上通过throws的关键字声明该功能有可能会出现问题。
int div(int a, int b)throws Exception
{
return a/b;
}
}

class ExceptionDemo
{
public static void main(String[] args)
{

  Demo d = new Demo();
  try
  {
   int x = d.div(4,0);
   System.out.println("x="+x);
  }
  catch(Exception e)//Exception e = new ArithmeticException();
  {
   System.out.println("除零了");
   System.out.println(e.getMessage());//输出异常信息
   System.out.println(e.toString());//异常名称：异常信息

   e.printStackTrace();//异常名称，异常信息，异常出现的位置
  //其实jvm默认的异常处理机制，就是在调用printStackTrace()方法
  //打印异常在堆栈的跟踪信息
  }
  System.out.println("over");

}
}

----------------------------------------------------------------------------------------------------------------------
class Demo
{
//在功能上通过throws的关键字声明该功能有可能会出现问题。
int div(int a, int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
{
  int[] arr = new int[a];
  System.out.println(arr[4]);

  return a/b;
}
}

class ExceptionDemo
{
public static void main(String[] args)
{
  Demo d = new Demo();
  try
  {
   int x = d.div(4,0);
   System.out.println("x="+x);
  }
  catch(Exception e)
  {
   System.out.prinltn("haha:"+e.toString());
  }
  /*
  catch(ArithmeticException e)
  {
   System.out.println(e.toString());
   System.out.println("除零了");
  }
  catch(ArrayIndexOutOfBoundsException e)
  {
   System.out.println(e.toString());
   System.out.println("角标越界了");
  }
  */
}
}

------------------------------------------------------------------------------------------

/*
因为项目中会出现特有的问题，
而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题可以按照java的对问题泛型的思想。
将特有的问题，进行自定义的异常封装。

自定义异常。

需求：在本程序中，对于除数是-1，也视为错误的是无法进行运算
的。那么就需要对这个问题进行自定义描述。

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch处理。
要么在函数上声明让调用者处理。

一般情况，函数内出现异常，函数上需要声明。

发现打印结果中只有异常的名称，却没有异常的信息。
因为自定义的异常并未定义信息。

如何定义信息呢？
因为父类中已经把异常信息的操作都完成了。
所以子类只有在构造时，将异常信息传递给父类，通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。

自定义异常：自定义类继承Exception.

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throw和throws操作。

throws和throw的区别：
throws使用在函数上。
throw使用在函数内。

throws后面跟的是异常类。可以跟多个，用逗号隔开。
throw后跟的是异常对象。
*/
class FuShuException extends Exception //getMessage()
{
private int value;

FuShuException(String msg, int value)
{
  super(msg);
  this.value = value;
}
public int getValue()
{
  return value;
}

/*
private String msg;
FuShuException(String msg)
{
  this.msg = msg;
}
public String getMessage()
{
  return msg;
}
*/
}

class Demo
{
int div(int a, int b)throws FuShuException
{
  if(b<0)
   throw new FuShuException("出现了除数是负数的情况----",b);//手动通过throw关键字抛出一个自定义异常
  return a/b;
}
}

class ExceptionDemo3
{
public static void main(String[] args)
{
  Demo d = new Demo();
  try
  {
   int x = d.div(4,-1);
   System.out.println("x="+x);
  }
  catch(FuShuException e)
  {
   System.out.println(e.toString());
   //System.out.println("除数出现负数了");
   System.out.println("错误的负数是"+e.getValue());
  }

  System.out.println("over");

}
}
/*
class Throwable
{
private String message;
Throwable(String message)
{
  this.message = message;
}
public String getMessage()
{
  return message;
}
}