《黑马程序员》java笔记->【03.2.1】关于异常-优快云博客

本文深入讲解Java中的异常处理机制，包括异常的抛出、捕捉、声明等关键概念，并介绍了如何自定义异常及运行时异常与编译时异常的区别。

------- android培训、java培训、期待与您交流！ ----------

/**
class Demo
{
int div(int a,int b)
{
  return a/b;//new ArithmeticExcption()封装异常对象。
}
}
class Demo44
{
public static void main(String[] args)
{
  Demo d=new Demo();
  int x=d.div(4,0);//抛出算数运算异常（new ArithmeticExcption()）--->抛给虚拟机JVM-->JVM用默认的处理方式处理收到的此异常，下面的语句就不运行了，结束进程。
  System.out.println("x="+x);
  System.out.println("over");
}
}
----------------------------------------------------
*/
/**
异常是可以处理的。
处理方式：
1:声明抛出。告诉调用者功能有问题，通过throws关键字对问题声明在功能上。
2:进行捕捉。可以使用针对性的捕捉代码块完成。
try
{
  //需要被检测的代码
}
catch(异常类变量) //该变量用于接受try检测到的异常对象。
{
  //异常处理代码
}
finally
{
  //一定被执行的代码
//主要用于释放资源，无论是否发生异常，有些动作一定要执行，放在finlly代码块中
//如连接数据库，储存完数据或者失败，都定要要关闭数据库释放资源
}

注意1：
如果catch()
{
//写了 return; 那么还会执行finally{}，在return之前
}
finally
{
}

注意2：
如果catch()
{
//写了 exit(0); 那么直接退出jvm，不执行finally{}
}
finally
{
}
--------------------------------
在进行一场捕捉时，代码块的不同组合情况

1，try catch finally

2，try catch //没有需要一定被执行的代码，不需要关闭资源的动作。

class Demo
{
void show()//这种情况不需要表示异常，因为内部已经被catch(){处理了}
{
  try
  {
   //直接在检测中抛出异常。
   throw new Exception();
  }
  catch(Exception)
  {
  }
}
}

3，try finally //一场并没有被处理，但是确实涉及到了资源的调用，资源需要被关闭。
所有就有了，被异常进行对外声明，因为没有catch,但是资源实在功能
内部打开的。必须要功能内部类关闭。就有了try和finally的组合

--------------------------
try
{}
catch()
{}
catch()
{}
catch()
{ try
{}
catch()
{}
cahtch()
{
  try
  {}
  ……
}
finally
{}
}
finally
{
}
---------------------------------------------------------
*/
/*
自定义异常：
对于常见的不正常情况，java都有对应的描述，比如角标越界，或空指针异常
对于自定义的程序中的出现的特有问题，java并没有给出对应的描述
这时就需要我们按照面向对象的思想对这个问题进行描述，象异常一样将其封装成对象。

定义的方式：
1，定义一个类，对问题进行描述
2，必须要让这个类继承异常类，具备可抛性。

异常细节：
1：如果多个catch中有父类异常（Exception），一定要定义在最下面。否则编译失败。
2:函数内throw抛出异常对象，函数上一定要throws声明，否则编译失败，

注意，异常分两种1，编译异常 2运行异常：
1：编译是被编译器检测的异常。编译异常
通常都需要编写针对性的处理代码进行处理。

2：编译时不被检测的异常，这种异常出现，编译时期是不在检查之列。这种异常称为运行时异常。
也就说【函数内throw抛出运行时异常，不需要在函数上声明】，即使声明了，调用者也不用一定给出
预先处理方式。因为他不会导致编译失败。
通常不编写针对性的代码进行处理，一旦发生，就让程序停掉，为了对代码进行修正。

两种异常区分方式：
Exception中一个特殊的子类：RuntimeException就是运行时异常。
RuntimeException和其子类都不需要编译时检测。

意味这：我们在自定义异常时，可以继承Exception，称为编译时被检测的异常。
也可以继承RuntimeException,称为运行时异常。

*/
class FuShuException extends Exception
{
private int num;
FuShuException()
{
  super();
}
FuShuException(String message)
{
  super(message);
}
FuShuException(int num)
{
  this.num=num;
}
public int getNum()
{
  return num;
}
}
class Demo
{
/*
int div(int a,int b) throws Exception//抛出异常
*/
int div(int a,int b) throws FuShuException,ArithmeticException
{
  if(b==0)//要想手动抛出一个异常对象，需要用到throw关键字。
   throw new ArithmeticException("完了，被零除了");
  else if(b<0)
   throw new FuShuException("错误，不允许除数为负数");
  else
   return a/b;   //默认new ArithMeticException("/ by zero");
}
}
class Demo44
{
public static void main(String[] args) //throws Exception
{
  Demo d=new Demo();
  try
  {
   int x=d.div(4,-1);
   System.out.println("x="+x);
  }
  catch(FuShuException e)//Exception e=new ArithmeticException();
  {
   System.out.println("message:"+e.getMessage());//信息
   System.out.println("toString:"+e.toString());//异常名称+信息
   System.out.println("负数是"+e.getNum());
   e.printStackTrace();//打印名称+信息+位置
  }
  catch(ArithmeticException e)
  {
   System.out.println("message:"+e.getMessage());//信息
   System.out.println("toString:"+e.toString());//异常名称+信息
   e.printStackTrace();//打印名称+信息+位置
  }
  System.out.println("over");
}
}
/**