java异常

Java异常 
什么是异常？ 
异常就是程序运行时出现的不正常情况。 

class Demo 
{ 
　　//除法运算 
　　public int div(int a, int b){ 
　　return a/b; 
　　} 
} 

Demo d = new Demo(); 
int x = d.div(4,0); 
System.out.print(x); 
System.out.println(“.over”); 
当调用者往里传入除数0，就发生了编译通过，运行失败的情况。 
出现了一个ArithmeticException: 
Jvm发现运算时已经违反了数学运算规则，java将这种问题进行描述， 
并封装成了对象：ArithmeticException。 
当除0运算发生后，jvm会将该问题打包成一个异常对象。 
New ArithmeticException（“/ by zero”）； 
Main函数收到这个问题时，有两种处理方式： 
1.自己将问题处理掉，然后进行运行 
2.自己没有针对性的处理方式，只有交给调用main的jvm来处理。 
Jvm有一个默认的异常处理机制，就将该异常进行处理。并将该异常的名称，异常的信息。异常出现的位置打印在了控制台上。同时将程序停止运行。 


其实异常就是程序中出现的问题，这个问题包括问题的名称，问题的信息，以及问题出现的位置。这个问题中内部中的有很多，按照面向对象将这个问题封装成了对象。 

通过if判断形势，也可以对问题进行处理。 
但是这样会导致，问题处理代码和正常的业务流程代码都定义在了一起，不便于阅读， 
当把问题封装成对象后，当该问题产生后，可以让程序进行跳转有一个特定的区域对问题惊醒处理，这样，异常的出现可以让问题代码和业务逻辑代码分离，提高了程序阅读性。 

Java对常见的一系列问题进行了描述，并进行对象的封装。 

问题分为两大类： 
1.可以处理的问题 
　　一般用Exception（异常）来进行描述，这个问题可以有针对性的处理 

2.重大错误问题 
　　用Error进行描述，这个问题发生后，一般不编写针对性的代码进行处理，而是要针对程序进行修正，通常都有jvm抛出的问题。 
　　 
这两个派系，他们的子类都有一个共同特征： 
所有子类名成结尾都是以父类名作为后缀。 
无论错误，异常，他们都有名称标示，同时也有问题的信息。问题出现的位置。 
既然有这样的共性，可以向上抽取， 
他们有了一个共同的父类Throwable，该父类定义了该体系中最共性的方法 


String getMessage():获取异常信息 
String toString():将异常对象变成字符串，其实覆盖了ObjecttoString方法 
void printStackTrace():打印异常在内存中的详细信息。（异常名称，异常信息，异常位置） 
没有进行try catch处理时，由jvm默认处理结果和printStackTrace()处理结果一样， 
说明jvm默认处理方式，就是在调用异常的printStackTrace()方法，并让程序停止。 
　　 
　　 
　　 
异常的处理： 
1.抛出throws 
2.使用java中指定的代码块进行自定义处理 
try{ 
　　需要检测异常的代码； 
} 
catch(异常类 变量){ 
　　异常处理代码； 
} 
finally{ 
　　一定会被执行的代码； 
} 

到底是try好还是throws好？ 
原则：如果该功能可以将问题处理，用try，如果处理不了，交由调用者处理，这时用throws。 


如果使用到了一个声明了异常的功能时， 
必须要对应的throws或者try的方式处理，否则编译失败。 
但是有一种情况。 
当功能上声明的异常是一个特殊的异常子类时，这时该功能被调用，可以不用任何处理方式，一样可以编译通过，这个特殊异常就是Exception中的一个子类RuntimeException。（运行时异常） 

异常分两种： 
1.编译时被检测的异常，包括除了Exception子类RuntimeException以外的所有异常。 
　　如果在函数上声明，如果调用时，没有处理方式，编译不通过。 
　　而且这种异常需要有针对性的处理方式，是可被处理的。 
2.编译时不被检测的异常：包括RunntimeException以及子类。 
　　该异常也称为运行时异常，如果功能声明了此异常， 
　　调用者可以不用任何处理方式。通过该异常不需声明。 
　　如果发生，就是需要程序停止，对代码进行修正。 
　　 
在自定义项目中，也会有很多问题发生，这些问题，有可能是项目特有问题， 
是没有被java所描述的。 
那么这时，就需要我们继续按照java的异常思想，将特有问题也封装成对象。 

自定义异常： 
将特有的问题进行描述，并封装成对象。 

自定义异常的步骤： 
　　定义一个类对问题描述。要想成为异常，必须继承异常类才可以。这样才可以成为异常体系中的一员。
　　其实最根本的原因：异常体系和其他对象的不同之处在于异常体系都具备可抛性。 
　　异常的类和对象都可以被两个关键字所操作：throw，throws 
　　 
if(b<0) 
{ 
　　throw new FuShuException(); //手动将异常封装成对象，并手动通过throw关键字将//异常抛出，引起程序的跳转，因为该异常发生后，运算时无法继续的 
} 


当函数内容通过throw抛出了一个编译时检测异常，必须有处理方式，要么try，要么throws 


调用了声明异常的函数，处理时，对方声明什么异常，我们就处理什么异常。 

自定义异常例子： 
class FuShuException extends RuntimeException{ 
　　FuShuException(String str){ //调用了父类的构造方法，将异常说明传递进去 
　　super(str); 
　　} 
} 

自定义异常可以继承Exception，也可以继承RuntimeException。 
如果该问题发生，不需要声明需要是修正代码，那么就需要继承RuntimeException 


throws和throw的区别？ 
1.throws用在函数上，用于声明该功能容易出现问题，可以调用者进行处理。 
throw用在函数内，用于抛出指定的具体异常对象。 
2.throws后面跟的是异常类，可以跟多个，中间用逗号隔开。 
throw后面跟的是异常对象。 
只有异常体系的类和对象才可以被这两个关键字所操作。 


异常的封装，将本层的特定异常进行本层的处理。通过处理完对外暴露将问题告诉调用者，给调用者提供一个可以处理的异常，这就是异常转换。 


关键字finally： 
无论怎么样都会执行到，除非退出jvm虚拟机 

什么时候使用finally？ 
用于关闭资源的代码。 

try catch finally在使用的时候 
try可以和catch相结合使用，也可以对应多个catch 

如果没有catch，try可以和finall结合使用。 
如果功能中，出现了编译时需要被检测的异常，如果没有被catch，就必须要throws声明，否则编译失败。

只有catch是处理异常的代码块。 

异常的处理细节： 
1.当子类覆盖父类时，如果父类的方法抛出了异常； 
　　那么子类覆盖父类要么不抛异常，那么抛出该异常或的该异常的子类。 
2.如果父类抛出了多个异常，子类覆盖父类时，只能抛出这些异常的子集。 

子类只能抛父类的异常或异常的子类或子集，子类不可以抛出父类没有的异常。 
注意：如果覆盖的方法没有异常抛出，那么子类的方法绝对不可以抛出异常。 
如果子类方法内还有异常发生，那么子类只能try，不能throws。 

面试细节：当try对应多个catch时，如果catch的类型有继承关系，那么父类型的catch一定要放在下面。