1.异常:java程序在运行时期发生的不正常情况,java按照面向对象的思想对不正常情况进行描述和对象封装
2.两种问题:
Throwable:定义了对于问题的共性的功能
|--Error:系统低层发生——>jvm——>调用者,不做针对性处理,直接修改代码
|--Exception:jvm发生——>调用者,可以进行针对性处理
3.异常处理:
1)遇到问题不进行具体的处理,而是继续抛给调用者。其实就是在函数上通过throws关键字声明异常,告诉调用者处理,
若一直没有得到针对性的处理,异常最终将会抛给jvm,jvm进行默认处理:在控制台输出错误信息
2)针对性的处理方式:捕获
try{
//有可能发生异常的代码
}
catch(异常类 变量){
//处理异常的代码
}
finally{
只有出现了System.exit(0);//退出jvm,该代码块才不会被执行(即使之前出现return ;也能执行)
//一定会被执行的代码
}
声明异常:
class Math{
public int div(int a,int b) throws Exception//声明异常
{
return a/b;//throw new ArithmeticException("/ by zero"):向上(main)抛出异常
}
}
class ExceptionDemo{
public static void main(String[] args) throws Exception//声明异常
{
Math d = new Math();
int res = d.div(4,0);//throw new ArithmeticException("/ by zero"):向上(jvm)抛出异常,程序运行至此就结束了
System.out.println(res);
System.out.println("Over");
}
}
捕获异常:
class Math{
public int div(int a,int b) throws Exception//声明异常
{
// if(b==0)
// throw new ArihmeticException("除数不能为零");//自定义异常信息
return a/b;//throw new ArithmeticException("/ by zero"):向上(main)抛出异常
}
}
class ExceptionDemo{
public static void main(String[] args)
{
Math d = new Math();
try{//有可能发生异常的代码
int res = d.div(4,0);
System.out.println(res);
}
catch(Exception e){//进行针对性处理,div扔出什么样的异常,此处便捕获什么样的异常
//Exception e = new ArithmeticException("/by zero")
System.out.println("ArithmeticException: / by zero");
System.out.println(e.getMessage());//异常信息
System.out.println(e.toString());//异常名称+异常信息
e.printStackTrace();//异常名字+信息+位置,jvm默认处理收到异常的方式
}
System.out.println("Over");//程序将会运行完毕
}
}
4.throw和throws的区别
1)位置不同:
throws用在函数上,后面跟的是异常类,可以跟多个
throw用在函数内,后面跟的是异常对象
2)功能不同:
throws用类声明异常,让调用者知道该功能有可能出现问题,并由调用者给出预先的处理方式
throw抛出具体问题对象,执行到throw该函数就结束,跳转到调用者,并将具体问题对象抛给调用者
也就是说throw语句独立存在时,下面不要写其他语句,执行不到
3)异常体系:体系中的类以及类所产生的对象都具备可抛性,即可以被throw和throws操作
Throwable
|----Error
|----Exception
5.异常抛出原则:
1)功能内部有异常throw抛出,功能上一定throws声明,且内部抛出什么异常,功能上就声明什么异常
2)特殊情况:
当函数内通过throw抛出了RuntimeException及其子类的异常对象时,函数上可以不用throws声明
原因:不声明的目的就是不让调用者处理,让调用者的程序停止,要对代码进行修改
Exception
|----编译时会被检测的异常
|----运行时异常(编译时不会检测)RuntimeException及其子类
5.自定义异常:定义一个除数不能为负数的异常
class FuShuException extends RuntimeException//继承运行时异常,函数内抛出,函数外不声明
{
FuShuException(String message){
super(message);//调用父类已有的方法
}
FuShuException(){
super();//构造函数重载overload
}
}
class Divide{
public int div(int a,int b){
if(b == 0)
throw new ArithmeticException("除数不能为0");
if(b < 0)
throw new FuShuException("除数不能为负数");
return a/b;
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Divide d = new Divide();
System.out.println(d.div(4,-2));
}
}
6.小结
1)异常:其实就是将问题封装成对象,并抛给调用者。如果函数上声明了,就需要调用者处理(继续声明或捕获)
2)声明或捕获:功能内部可以解决,就捕获;不能解决,或者解决了还必须告诉调用者问题,就该声明
3)一try{}多catch{}
4)异常转换:封装本层异常,对外暴露调用者能处理的异常。
class Computer{
private int state = 2;//computer normal
public void run() throws BlueScreenException,SmokeException{//声明多种异常,多catch来捕获不同的异常
if(state == 1)
throw new BlueScreenException("BlueScreen...");
if(state == 2)
throw new SmokeException("Smoking...");
System.out.println("Running...");
}
public void reset(){
state = 0;
System.out.println("Resetting...");
}
}
//电脑异常:蓝屏
class BlueScreenException extends Exception{
BlueScreenException(){
super();
}
BlueScreenException(String message){
super(message);
}
}
//电脑异常:冒烟
class SmokeException extends Exception{
SmokeException(){
super();
}
SmokeException(String message){
super(message);
}
}
class Teacher{
private String name;
private Computer com;
Teacher(String name){
this.name = name;
com = new Computer();
}
public void lecture() throws StopException{
try{
com.run();
System.out.println("Speaking...");
}
catch(BlueScreenException e){
System.out.println(e.toString());//输出异常信息
com.reset();//电脑重启
lecture();//继续讲课
}
catch(SmokeException e){
System.out.println(e.toString());
throw new StopException("Stopping lecture...");//捕获电脑冒烟异常,向老师抛出讲课进度停止异常
//异常转换:捕获本层异常,对外暴露调用者能处理的异常
}
}//一try多catch
}
//老师异常:讲课进度停止
class StopException extends Exception{
StopException(){
super();
}
StopException(String message){
super(message);
}
}
class CompanyDemo
{
public static void main(String[] args)
{
Teacher t = new Teacher("毕向东");
try{
t.lecture();
}
catch(StopException e){
System.out.println(e.toString());
System.out.println("change teacher...");//更换老师
}
}
}
7.数据库异常流程
finally的作用:无论是否有异常发生,都要对资源进行释放。资源释放动作就定义在fianlly代码块中
class App{
public void useDB(){
DBtool d = new DBtool();
try{
d.operate();
}
catch(NoValueException e){
}
}
}
class DBtool throws NoValueException{
public void operate(){
//connect DB
try{
//operate DB
throw new SQLException();
}
catch(SQLException e){
//solve SQLException
throw new NoValueException();
//在数据库工具类中解决数据库的异常,但仍需向调用者抛出没有返回值异常,以告诉调用者
}
finally{
//close DB
}
}
}
8.捕获异常处理的几种组合方式:
1.没有资源要释放,仅做异常处理
try{
}
catch(){
}
2.一try多catch,一般对应的是被调用的函数,抛出多个异常情况,分别处理
try{
}
catch(){
}
catch(){
}
注意:如果catch中的异常类存在子父类,父类异常的catch一定要放在子类异常catch的下面,
否则编译失败。
3.不一定要处理异常,但是有资源要释放
try{
}
finally{
}
4.既处理异常,也要释放资源
try{
}
catch{
}
finally{
}
9.覆盖时的异常
子类方法覆盖父类方法只能抛出父类方法的异常或者该异常的子类;
如果父类方法抛出多个异常,子类只能抛出父类异常的子集;
原则:就是子类的异常必须要在父类的异常处理控制中。
注意:只能try,不能throws的情况:
被覆盖的方法没有抛出异常,那么子类在覆盖时,子类方法中发生了异常就只能try无法throws声明。
interface Inter{
void show();
}
class Demo implements Inter{
void show(){
try{
throw new Exception();
}
catch(Exception e){
//若无法解决
throw new RuntimeException();//将编译时异常转化为运行时异常,就无需在函数生声明
}
}
}