java个人学习笔记14（Error+Exception+try_catch_finally+throw+throws）

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();//将编译时异常转化为运行时异常，就无需在函数生声明
}
}
}