异常

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

在java中用类的形式对不正常的情况进行了描述和封装对象。

Throwable：

1 一般不可处理的 Error

2 可以处理的Exception

throws,throw,凡是可以被这两个关键字所操作的类都具备可抛性

注意：如果让一个类称为异常类，必须要继承异常体系，才具有可抛性，被throws，throw操作。

throws 用于在函数声明时 

例：

public int method(int[] arr,int index) throws FunShunIndexException

public static void main(String[] args) throws FuShuIndexException

异常的分类：

1 编译时检测异常：只要是Eception和其子类都是，除了特殊子类RuntimeException

这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。

2 编译时不检测异常（运行时异常）： 就是Exception中的RuntimeException和其子类

这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致

的而引发了内部状态的改变。那么这种问题一般不处理，直接编译通过，运行时

调用时让调用者调用的程序停止。可以不需要声明。

所以自定义异常时，要么继承Exception，要么继承RuntimeException

throws 和 throws的区别：

1 throws 用在函数上，throw用在函数内。

2 throws抛出的是异常类，可以抛出多个，用逗号隔开。

   throw抛出的是异常对象

异常捕捉：

具体格式：

try{ //需要被检测异常的代码   }

catch(异常类 变量)//该变量用于接收发生的异常对象

{//处理异常的代码}

finally{  //一定会执行的代码  }

例：

class FuShuIndexException extends Exception
{
FuShuIndexException()
{}
FuShuIndexException(String msg) //调用父类Exception中的构造方法
{
super(msg);
}
}
class Demo
{
public int method(int[] arr,int index) throws FuShuIndexException
{
if(index<0)
throw new FuShuIndexException("负数角标异常！！！");
return arr[index];
}
}


class  ExceptionDemo
{
public static void main(String[] args) //throws FuShuIndexException
{
int[] arr = new int[3];
Demo d = new Demo();
try
{
int num = d.method(arr,-1);
System.out.println("num+"+num);
}
catch (FuShuIndexException e)//相当于FuShuIndexException e =  new FuShuIndexException()
{
System.out.println("负数角标异常！！！");
}
System.out.println("over");
}
}

多catch：

多catch的情况下，catch(Exception e)放最后，因为Exception e 相当于调用了所有的异常类。

异常处理的原则：

1 函数内容，如果抛出需要检测的异常，那么函数上必须要声明，否则必须在函数内用try catch，否则编译失败

2 如果调用到了声明异常的函数，要么try catch，要么throws 否则编译失败

3 什么时候catch,什么时候throws呢？

功能内容可以解决，用catch，解决不了用throws告诉调用者，由调用者解决

4 一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理，内部有几个需要被检测的异常，就抛出几个异常

异常—finally代码块

finally：通常用于关闭释放资源

try catch finally 代码块组合特点

1 try catch finally

2 try catch(多个)

3 try fianlly 异常无法直接catch处理，但是资源需要关闭

异常的注意事项：

1子类覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类

2 如果父类抛出多个异常，子类只能抛出父类异常的子集，简单说，子类覆盖父类只能抛出父类异常的子集

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

异常应用：

/*
毕老师上课用电脑。
问题涉及两个对象，电脑和老师
分析其中的问题:
电脑蓝屏，冒烟啦
*/
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 = 0;
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 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("换人");
}

}
}