黑马程序员--异常-CSDN博客

本文链接：https://blog.csdn.net/fansangg/article/details/49391357

异常

1.异常：就是程序在运行时出现的不正常情况。

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

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

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

对于Error一般不编写针对性的代码对其进行处理

对于非严重的，java通过Exception类进行描述

对于Exception可以使用针对性的处理方式进行处理

无论Error或者Exception都具有一些共性问题。

比如：不正常的情况的信息，引发原因等；

Throwable

-----Error

-----Exception

2.异常的处理

Java提供了特有的语句进行处理。

Try

{

·需要被检测的代码；

}

Catch(异常类变量)

{

处理异常的代码：（处理方式）

}

Finally

{

一定会执行的语句；

}

3.对捕获到的异常对象进行常见方法操作。

String getMessaage（）；打印异常信息

toString（）；异常名称：异常信息

e.printStackTrace（）；异常名称。异常信息，异常出现的位置。其实jvm默认的处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息。

//异常的练习 try catch getMessage（） tostring（） printStackTrace
class Demo
{
int div(int x ,int y)throws Exception
{
return x/y;
}
}
class Day9_6
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(9,0);
System.out.println("x="+x);
}
catch (Exception e)
{
System.out.println("捕获成功");

System.out.println(e.getMessage());//异常信息 / by zero
System.out.println(e.toString());//异常名称：异常信息
e.printStackTrace();//异常名称，异常信息，异常出现的位置。就是jvm 处理异常的机制
}

System.out.println("over");
}
}

4.对多异常的处理

1）声明异常时，建议声明更为具体的异常，这样处理的可以更具体。

2)对方声明几个异常，就对应有几个catch块。不要定义多余的catch块

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面

建议在进行catch处理时，catch中一定要定义具体的处理方式。

不要简单的定义一句e.printStackTrace();

也不要简单的就书写一条输出语句。

//多异常
class Demo2
{
int div(int x ,int y)throws ArithmeticException,ArrayIndexOutOfBoundsException
{
int array[] = new int[x];
System.out.println(array[4]);
return x/y;
}
}
class Day9_8
{
public static void main(String[] args) throws Exception
{
Demo d = new Demo();
try{
int x = d.div(3,1);
System.out.println("x="+x);
}
catch (ArithmeticException e)
{
System.out.println("有零");
System.out.println(e.toString());
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println("11");
System.out.println(e.toString());
}

System.out.println("over");
}
}

自定义异常

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。

所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题，进行自定义的异常封装。

自定义异常

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

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

发现打印的结果中只有异常的名称，缺没有异常的信息。

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

自定义异常：

必须是自定义类继承Exception。

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

//自定义异常
class FushuException extends Exception
{
private int value;
FushuException()
{
super();
}
FushuException(String msg,int value) //
{
super(msg);
this.value = value;
}
public int getValue()//特有数据生成的方法
{
return value;
}

}
class Demo3
{
int div(int a ,int b) throws FushuException
{
if (b<0)
{
throw new FushuException("负数异常了 -------------",b);
}
return a/b;
}
}
class Day9_9
{
public static void main(String[] args)
{
Demo3 s = new Demo3();

try
{
int x = s.div(5,-1);
System.out.println(x);
}
catch (FushuException e)
{
System.out.println(e.toString());
System.out.println("您所输入的输是:"+e.getValue());
}
}
}