1,、异常-概述
异常：就是程序在运行时出现不正常情况。
异常由来：问题也是现实生活中一个具体的事物，
也可以通过java的类的形式进行描述，并封装成对象。
其实就是java对不正常情况进行描述后的对象体现，通过JVM异常处理机制。
对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
对于严重的，java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
例：
class ExceptionDemo
{
public static void main(String[] args)
{
byte[] arr=new byte[1024*1024*190];
}
}
对于非严重的，java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
例：
无论Error或者Exception都具有一些共性内容，
比如：不正常情况的信息，引发原因等。
Throwable(可抛，是所有异常的超类)
|--Error
|--Exception
Error类中的子类共性：末尾以Error结尾
Exception类中的子类共性：末尾以Exception结尾，疾病
2、异常-处理
java提供了特有的语句进行处理，针对Exception
try
{
需要被检测的代码;
}
catch(异常类 变量)
{
处理异常的代码：(处理方式)
}
finally
{
一定会执行的语句;
}
对捕获到的异常对象进行常见方法操作。
e.getMessage();
e.toString();异常名称:异常信息
e.printStackTrace();
catch(Exception e)
{
System.out.println(e);
System.out.println(e.getMessage());
System.out.println(e.toString());
e.printStackTrace();//异常名称:异常信息，异常出现的位置。
//其实jvm默认的异常处理机制，就是在调用printStackTrace()，打印异常的堆栈跟踪信息。
}
3、异常-声明
throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
class Demo
{
int div(int a,int b)throws Exception<span style="font-family:Microsoft YaHei;">//声明可能会出现问题</span>
{
return a/b;
}
}
class ExceptionDemo1
{
public static void main(String[] args)
{
Demo d=new Demo();
int x=d.div(4,1);
System.out.println(x);
System.out.println("over");
}
}
就是告诉你上面这个Demo类中的div方法可能会出现问题，要用try-catch()
4、多异常处理
对多异常处理，
1，声明异常时，声明更为具体的异常，这样处理的可以更具体。
函数发生异常，就立即结束。
2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系，父类异常块在最下面。
建立在进行catch处理时，catch中一定要定义具体处理方式。
不要简单定义一句e.printStackTrace()，也不要简单就书写一条输出语句。
5、自定义异常
你们有发现，JAVA体系当中分为两大派，异常和错误。
异常有很多小弟，这些小弟的出现，是因为java将常见的问题进行封装。
比如算术异常，脚标异常进行封装。那么就有一个小问题，
因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题可以按照java对问题封装的思想。
将特有的问题，进行自定义的异常封装。
需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的。
那么就需要对这个问题进行自定义的描述。手动抛出。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部try catch处理。
要么在函数上声明让调用者处理。
一般情况，在函数内出现异常，函数上需要声明。
结果：
发现打印的结果中只有异常的名称，却没有异常的信息。
因为自定义的异常并未定义信息
如何定义异常信息呢？将以上文件修改
class FuShuException extends Exception
{
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("出现了除数是负数的情况/by fushu");//手动通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
结果：
toString()调用getMessage()
简化：
class FuShuException extends Exception
{
FuShuException(String msg)
{
super(msg);
}
}
因为父类中已经把异常信息的操作都完成了，
所以子类只要在构造时，通过super语句将异常信息传递给父类，
那么就可以直接通过getMessage方法获取自定义异常信息。
抛出错误值：
class FuShuException extends Exception
{
private int value;
FuShuException(String msg,int value)
{
super(msg);
this.value=value;
}
public int getValue() //多定义了个getValue方法
{
return value;
}
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("出现了除数是负数的情况/by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
Demo d=new Demo();
try
{
int x=d.div(4,-3);
System.out.println("x="+x);
}
catch(FuShuException e)
{
System.out.println(e.toString());
//System.out.println("出现负数");
System.out.println("错误的负数是："+e.getValue());//获取gerValue方法返回的值
}
}
}
自定义异常总结：
必须是自定义类继承Exception或Error或Throwable。
继承Exception原因：
异常体系有一个特点，异常类和异常对象都被抛出。
它们都具备可抛性，这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw
throws和throw的区别：
throws使用在函数上，
throw使用在函数内；
throws后面跟异常类。可以跟多个，用逗号隔开.
throw后面跟异常对象。