Java语言基础-异常

异常

是在运行时期发生的不正常情况

在Java中用类的形式对不正常情况进行了描述和封装对象；
描述不正常的情况的类，就称为异常类；

以前正常流程代码和问题处理代码相结合，
现在讲正常流程代码和问题处理代码分类，提高阅读性；

其实异常就是Java通过面向对象的思想将问题封装成了对象，
用异常类对其进行描述；
不同的问题用不同的类进行具体的描述；比如角标越界，空指针等；

问题很多，意味着描述的类也很多，
将其共性进行向上抽取，就形成了异常体系；

最终异常分为两大类：
Throwable：无论是Error还是异常，都是问题，问题发生就应该抛出，让调用者知道并处理。
该体系的特点：Throwable及其所有的子类都具有可抛性。
子类的后缀名都是用其父类名作为后缀，阅读性强；
如何体现可抛性？
通过两个关键字来体现：throws、throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性；

1.一般不可处理的：Error
特点：是由JVM抛出的严重性的问题，影响到程序的执行；
这种问题发生一般不针对性处理，而是直接修改程序；
2.可处理的：Exception

如果有未定义的异常，需要按照Java异常的创建思想，面向对象，将负数下标进行自定义描述，并封装成对象。
这种自定义的问题描述叫做自定义异常。

注意：如果让一个类成为异常类，必须要继承异常体系，因为只有成为异常体系的子类，
才有资格具备可抛性，才可以被两个关键字所操作：throw(函数)，throws(函数声明)
如果函数发生了异常，需要在函数上声明，否则编译失败；

异常的分类：
1.编译时被检测异常：只要是Exception和其他子类都是(出了特殊子类RuntimeException体系)；
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式；
这样的问题都可以针对性的处理。
2.编译时不检测异常(运行时异常)：就是Exception中的RuntimeException和其子类。
这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的，
或者引发了内部状态的改变导致的。
这种问题一般不处理，直接编译通过，在运行时，让调用时的程序强制停止，让调用者对代码进行修正。
自定义异常时，继承Exception或者RuntimeException。

注意：1.throws使用在函数上，throw使用在函数内；
2.throws抛出的是异常类，可以抛出多个，用逗号隔开，
throw抛出的是异常对象。
异常处理的捕捉形式：
这是可以对异常进行针对性处理的方式；
具体格式是：

try
{
//需要被检测异常的代码
}
catch(异常类 变量)//该变量用于接收用于接收发生的异常对象
{
//处理异常的代码
}
finally
(
//一定会执行的代码
)

异常处理示例

class FuShuIndexException extends Exception
{
FuShuIndexException()
{
}
FuShuIndexException(String msg)
{
super(msg);//调用父类即可
}
}

class Demo
{
public int method(int[] arr,int index) throws FuShuIndexException,NullPointerException
{
if(arr==null)
throw new NullPointerException("没有任何数组实体");
if(index<0)
throw new FuShuIndexException("下标不能为负数");
return arr[index];
}
}

class ExceptionDemo4
{
public static void main(String[] args)
{
int[] arr=new int[3];
Demo d=new Demo();
try
{
int num=d.method(arr,3);
System.out.println("num="+num);
}
catch (NullPointerException e)
{
System.out.println(e.toString());
}
catch (FuShuIndexException e)
{
System.out.println("message:"+e.getMessage());
System.out.println("string"+e);//System.out.println("string:"+e.toString());默认效用toString()
e.printStackTrace();//JVM默认的异常处理机制就是么偶人调用异常对象的这个方法
}
/*
catch (Exception e)//多catch，父类的catch放在最后，否则，编译失败
{
System.out.println("其他异常：\n"+e);
}
*/
System.out.println("over");
}
}

异常处理的原则:
1.函数内部如果抛出需要检测的异常，那么函数上必须要声明；
否则必须在函数内用try-catch捕捉，否则编译失败。
2.如果调用到了声明异常的函数，要么try-catch，要不throws，否则编译失败；
3.什么时候catch，throws
功能内部可以解决，用catch；
无法解决用throws，告诉调用者，由调用者解决;
4.一个功能如果抛出多个异常，那么调用时必须有对应的多个catch进行针对性处理；
内部有几个需要检测的异常，就抛出几个异常，抛出几个异常就catch几个异常。

try-catch-fianlly代码块组合特点
1.try-catch-fianlly
2.try-catch 没有必要资源需要释放时，可以不用定义finally；
3.try-finally 异常无法直接catch处理，但是资源需要关闭；

void show() throws Exception//没有catch时必须声明
{
try
{
//开启资源
throw new Exception();
//关闭资源
}
finally
{
//出现异常时，关闭资源
}
}

finally使用示例

class Demo
{
public int show(int index) throws ArrayIndexOutOfBoundsException
{
if(index<0)
throw new ArrayIndexOutOfBoundsException("下标越界");
int[] arr=new int[3];
return arr[index];
}
}

class  ExceptionDemo5
{
public static void main(String[] args)
{
Demo d=new Demo();
try
{
int num=d.show(-3);
System.out.println("num="+num);
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
//return;
//System.exit(0);//结束JVM，后面所有语句都不执行
}
finally//通常用于关闭(释放)资源
{
System.out.println("finally");
}
System.out.println("over");
}
}

try-catch-finally综合使用示例

/*
必要时用电脑上课
问题领域中涉及两个对象：毕老师，电脑
分析其中的问题：
电脑蓝屏，无法使用
*/
class LanPingException extends Exception
{
LanPingException(String msg)
{
super(msg);
}
}
class MaoYanException extends Exception
{
MaoYanException(String msg)
{
super(msg);
}
}

class NoPlanException extends Exception
{
NoPlanException(String msg)
{
super(msg);
}
}
class Computer
{
private int state=2;
public void run() throws LanPingException,MaoYanException
{
if(state==1)
throw new LanPingException("电脑蓝屏");
if(state==2)
throw new MaoYanException("电脑冒烟");
System.out.println("电脑运行");
}
public void reset()
{
state=0;
System.out.println("电脑重启");
}
}

class Teacher
{
private String name;
private Computer comp;
Teacher(String name)
{
this.name=name;
comp=new Computer();
}
public void prelect() throws NoPlanException
{
try
{
comp.run();
System.out.println(name+"讲课");
}
catch (LanPingException e)
{
System.out.println(e.toString());
comp.reset();
prelect();
}
catch (MaoYanException e)
{
System.out.println(e.toString());
test();
//可以对电脑进行维修
//throw e;
throw new NoPlanException("课时进度无法完成："+e.getMessage());//异常转换
}
}
public void test()
{
System.out.println("大家练习");
}
}

class ExceptionTest
{
public static void main(String[] args)
{
Teacher t=new Teacher("毕老师");
try
{
t.prelect();
}
catch (NoPlanException e)
{
System.out.println(e.toString()+"..........");
System.out.println("换人");
}
}
}

/*
异常的封装
class NoAddException extends Exception
{}

void addData(Data d)throws NoAddException
{

连接数据库
try
{
添加数据。出现异常 SQLException();
}
catch(SQLException e)
{
//处理代码。
throw new NoAddException();
}
fianlly
{
关闭数据库。
}
}
*/

异常的注意事项：
1.子类在覆盖父类方法时，父类的方法如果抛出了异常，
那么子类的方法只能抛出父类的异常或者该异常的子类；
2.如果父类抛出多个异常，那么子类只能抛出父类异常的子集；

简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集；

注意：如果父类的方法没有抛出异常，那么子类覆盖时不能抛出异常，只能try；