黑马程序员--异常机制处理笔记总结
异常
就是程序在运行时出现的不正常的情况
异常的由来，问题是现实一个具体的事物，也可以通过java类来进行描述
其实就是java对不正常情况进行描述后的对象体现
对于问题划分，严重的：java通过error类进行的描述
非严重的：java通过exception类进行描述
对于execption可以通过针对性的处理方式进行的处理
处理异常格式
Try{
需被检测的代码
}
Catch(exception e){
处理异常方式
}
Finally
{
一定会执行的语句
}
也可以用throws Exceptions来抛出异常
多异常处理
1，声明异常时，建议声明更为具体的异常，这样处理可以更具体
原则：对方声明几个异常，就对应几个catch块
父类catch要放最下面不要定义多余的catch块
建议在catch处理时，catch中一定要定义具体的处理方式
不要简单的一句 e.printStackTrace();
多种处理异常的方式
class Exceptiondemo
{
public static void main(String[] args)
{
Demo d=new Demo();
try{
int x=d.div(5,0);
System.out.println("x="+x);
}
catch(ArithmeticException e)//算术异常
{
System.out.println(e.toString());
}
catch(ArrayIndexOutOfBoundsException e)//越界异常
{
System.out.println("角标越界");
}
catch(Exception e)//这是抛出所有异常，当时什么异常不具体、{
System.out.println(e.toString());
}
}
}
class Demo
{
int div(int a,int b)
{
int[] arr=new int[a];
System.out.println(arr[4]);
return a/b;
}
}
自定义异常
但在函数内部出现throw抛出异常对象，那么就必须个对应的处理对象
要么在内部trycatch处理
要么让调用者处理
一般情况下，函数内出现异常，函数上需要声明
自定义类继承Exception。
继承Exception原因
异常体系有一个特点，因为异常和异常类都被抛出
他们都具有可抛性，这个可抛性是Throwable这个体系中独有的
Throw和throws的区别
Throw单独存在时throw后main不要在写语句
都是抛出异常
Throws使用在函数上 是向用户抛出异常
Throw使用在函数内
Throws后面跟的是异常类可以跟多个，用逗号隔开
Throw后面跟多是异常对象
Exception中有一个特殊的异常较RuntimeException运行时异常
如歌在函数内抛出异常，函数上可以不用声明，编译一样通过
如果函数在声明上该异常，调用者可以不进行处理，
注意，之所以不用在函数上声明是因为不需要调用者处理
当该异常发生，希望程序停止，因为子啊运行时，出现了无法继续运算的情况，希望停止程序
对代码修改
自定义异常时如果该异常发生没在继续运算的话
就让自定义异常继承RuntimeException 非常有效
同时继承RuntimeException是也不用在函数上标识，异常后面所有的 都不在执行了
Throw单独存在时函数的结束标识，后面就不要写东西了
除了他，还有return也是函数的结束标识
class Demo
{
int div(int a,int b) throws FushuException
{
if(b<0)
throw new FushuException("出为零");
return a/b;
}
}
这种问题我们要用FushuException抛出去，因为这种问题是开发者无法
出来的 而是客服端的用户造成的，跑出去只有让用户去处理，比如把b<0
该穿b>0
Finally
非常重要，主要是链接数据库，关闭资源
Finally代码块，一定执行的代码
用于关闭资源
Try
{
}
Catch（SQLException e）{
会对数据库进行异常处理
}
Finally
{
关闭数据库
}
异常处理有三种格式
第一种
Try
{
}
Catch()
{
}
第二种
Try{
}
Catch（）
{
}
Finally
{
}
第三种
Try
{
}
Finally
{
}
记住一点
Catch是用于处理异常的
异常 覆盖时异常的特点
子类在覆盖父类是如果父类的方法抛出异常，那么子类的覆盖方法
只能抛出父类的异常或者改异常的子类
如果父类抛出多个异常，那么子类只能抛出父类 的子异常
如果父类猴子接口方法中没有异常抛出那么子类在覆盖方法是也不可以抛出异常、
如果子类方法发生异常就必须要进行try处理决定不能抛
下列是使用RuntimeExcepiton.抛出异常
class Novale extends RuntimeException
{
Novale(String msg)
{
super(msg);
}
}
interface Shape
{
void getare();
}
class Rec implements Shape
{
private int len,wid;
Rec(int len,int wid) //throws Novale
{
if(len<=0||wid<=0)
throw new Novale("输入非法");
this.len=len;
this.wid=wid;
}
public void getare()
{
System.out.println(len*wid);
}
}
class Circle implements Shape
{
private int banjin;
public static final double Pi=3.14;
Circle(int banjin)
{
if(banjin<=0)
throw new Novale("输入非法");//这里即可创建自定义的Novale对象，也可以创建RuntimeException对象，创建RuntimeException对象，创建RuntimeException对象就不用再函数上使用自定义对象了
this.banjin=banjin;
}
public void getare()
{
System.out.println(banjin*banjin*Pi);
}
}
class Getare
{
public static void main(String[] args)
{
Rec r=new Rec(4,5);
r.getare();
Circle c=new Circle(-9);
System.out.println("over");
}
}
异常，是对问题的 描述将问题进行对象封装，
异常体系，Throwable
||--Error
|--Exception
|---RuntimeExceptio
异常体系中的所有类以及建立对象都具有可抛性也就是说可以别throws和throw所操作、
只有异常具有这个特点
Throws可以定义在函数上，可以抛出多个异常，用逗号隔开
当函数内throw抛出异常，并进行try处理，必须子啊函数上声明，否则失败
RuntimeException除外，在函数内抛出RuntimeException在函数上可以不声明
如果声明了，调用者需进行处理，方法可以throw可以try
编译时被检测异常
该异常，编译时，如果没有处理编译失败
运行异常
在编译时，不需要处理，编译器不检查
该异常的发生，建议不处理，让程序停止，需对代码修正
代码
Try
{
要被检测的代码
}
Catch（）
{
处理异常的代码
}
Finally
{
一定要执行的代码
}
如果在Catch中写
System，exit（0）；
是finally不会被执行
自定义异常
定义类继承Exception或者RuntimeException
为了让该类自定义具备可以抛性
自定义异常，可以用父类定义好的功能
class My extends Exception
{
My(String msd)
{
super(msd);}
}
自定义异常，是按照java面向对象思想，将程序中特有问题封装
