异常处理

异常处理：

/**

*异常: 就是程序在运行时出现不正常情况

*异常由来: 问题也是现实生活中的事物,也可以通过java类的形式进行描述,并进行封装.

*

*对于问题的划分:

* 1: 严重的问题 (Error) : java通过Error类进行描述,一般不编写针对性的代码进行处理

* 2: 非严重的问题 (Exception): java通过Exception类进行描述,一般使用针对性的处理方式进行处理

*

*无论 Error 或者 Exception 都具有一些共性的内容

*比如: 不正常的情况信息,引发原因等

* 所以就出现了 "Throwable" 这个父类

*

* Throwable

* |--Error

* |--Exception

*

*

*2.异常的处理

* java 提供了特有的语句进行处理

*

* try{

* 需要被检测

* }catch(异常类 变量){

* 出来异常的代码:(处理方式)

* }finally{

* 一定会执行的语句

* }

*

* 3.对捕获到的异常信息进行处理

* 1. String getMessage(); //打印 异常信息

* 2. String toString(); //打印 异常名称 : 异常信息

* 3. void printStackTrace(); //打印最全名: 异常 名称 : 异常信息 : 异常位置 ; 是 JVM 默认异常处理机制,就是调用这个方法

*

* 4.问题: 发现下面的程序有时候能正常运行,有时候不能, 因为不是所以认得知道这个方法会抛出异常 ,也不是所有人都会处理 这个异常. 怎么办 ?

* 所以就出现 throws 抛出异常

*/

class Demo{

static int div(int a,int b){

return a/b;

}

}





public class ExceptionDemo {

public static void main(String[] args) {

//exception

try{

int x=Demo.div(4, 0); //除数不能为0 ,抛出 new ArithmeticException(); 程序会终止

System.out.println("x="+x); //出现异常后 这句话就不会被执行 直接进入 catch 语句块中去了

}catch(Exception e){ // Exceptioin e= new ArithmeticException();

System.out.println("除数为0啦!");

System.out.println(e.getMessage()); // "/ by zero"

System.out.println(e.toString());//toString() 可以省略 打印 异常名称 : 异常信息

e.printStackTrace(); //打印最全名: 异常 名称 : 异常信息 : 异常位置.



}

System.out.println("run over"); //运行 完 catch语句块后 , 接着运行 这句



//error

byte[] arr=new byte[1024*1024*6000];

//超出虚拟据总内存大小 不管在怎么样 也不能超过物理内存大小 ,这程序也没戏了.

}

}

throws 多异常处理

Java代码


/**

* throws

* 1. throws: 在功能上通过throws的关键字声明该功能有可能出现问题.

*

* 2.被声明后 我们必须告诉程序的处理方式

* 1.采用 try catch 进行处理

* 2.继续抛出 异常 ,由jVM 虚拟机 进行异常处理 不过这样 程序 就会终止.

*

*

* 多异常的处理

* 1.声明异常时,建议声明更为具体的异常,这样 处理的可以更具体

* 比如: 下面 throws ArithmeticException 而不写成 throws Exception

*

* 2.对于声明多个异常,在调用的时候就应该有几个 catch块.不要定义多余的catch块 ,比如下面注释的 catch块

* 如果多个catch中的异常出现了继承关系,父类异常catch块 放在最下面 .

*

* 建议:在进行catch处理时,catch一定要定义具体的处理方式

* 不要简单的一句. e.printStackTrace();

* 也不要简单的就书写一条输出语句 ,一般采用log日志文件 进行 异常信息记录

*

*/



class Demo{

static int div(int a,int b) throws ArithmeticException{



return a/b;

}

}



class Demo1{

static int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException{

int [] arr=new int[a];

System.out.println(arr[a+1]); //出现越界

return a/b;

}

}



public class ExceptionDemo1 {



/**

* thrwos

*/

public static void main(String[] args) {

// 使用第一种方法处理

try {

Demo.div(4, 0);

} catch (Exception e) {

System.out.println(e.toString());

}

}



// 使用第二种方法处理 继续往上抛出异常 让 JVM 帮我处理

public static void otherMethod() throws ArithmeticException{

Demo.div(4, 0);

}



/**

* 多异常处理

*/

public static void otherMethod1() throws ArithmeticException,ArrayIndexOutOfBoundsException{

Demo1.div(4, 0);

}



public static void otherMethod2() {

try {

Demo1.div(4, 0);

} catch (ArithmeticException e) {

System.out.println(e.toString());

System.out.println("被0除了");

}catch(ArrayIndexOutOfBoundsException e){

System.out.println(e.toString());

System.out.println("角标越界");

}/*catch(Exception e){ //这样做只会隐藏 异常 ,这样做是不对的

System.out.println(e.toString());

}*/



}



}

throws 和throw 的区别

自定义 异常类

Java代码

/**

* 因为项目中会出现特有的问他你.

* 而这些问题并未被java所描述和封装成对象

* 所以对于一些特有的问题可以安装java的对问题封装的思想.

* 将特有的问题,进行自定义的异常封装

*

*

* 自定义异常

*

* 需求: 在本程序中,对于除数 是-1 也视为错误的,是无法进行运算.

* 那么就需要对这个问题进行自定义的描述.

*

*当函数内部初相了throw抛出异常对象,那么就必须要给对应的处理动作.

*要么在内部 try catch 处理

*要么子啊函数上声明让调用者处理.

*

*一般情况下, 函数内部出现异常,函数上需要声明.

*

*发现 打印的结果中只有异常的名称,却没有异常的信息

*因为自定义的异常并未定义信息

*

*如何定义异常信息呢?

* 因为父类中已经把异常信息的操作都做完了

* 所以子类只要在构造时,将异常信息传递给父类通过super语句

* 就可以直接通过getMessage获取自定义的异常信息

*

*自定义异常:必须是自定义类继承 Exception

*

*继承Exception原因:

* 异常体系有一个特点,因为异常类和异常对象都被抛出

* 因为他们都具备可抛性,这个可抛性是Trowable这个体系中独有的特点.

*

* 只有这个体系中的类和对象才可以被throw 和 throw 操作

*

*throws 和throw 的区别

*throws:使用在函数上

*throw:使用在函数内

*

*throws:后面跟的异常类,可以跟多个,用逗号分开

*throw:后跟的是异常对象.

*/

class FuShuException extends Exception{



/*

private String msg;

FuShuException(String msg){

this.msg=msg;

}

public String getMessage(){

return this.msg;

}

*/

FuShuException(String msg,int num){

super(msg);

this.value=num;

}

private int value;



public int getValue(){

return value;

}



}



//自定义 异常类

class Demo{



static int div(int a,int b) throws FuShuException{

if(b<0)

throw new FuShuException("出现了除数为零的情况 / by fushu",b); //手动通过throw 关键字抛出一个自定义异常对象.

return a/b;

}

}





public class ExceptionDemo2 {



public static void main(String[] args) {

// TODO Auto-generated method stub

try {

Demo.div(4, -1);

} catch (FuShuException e) {

System.out.println(e.toString());

System.out.println("除数出现负数了!");

System.out.println("负数是:"+e.getValue());

}

System.out.println("over");

}



}

RuntimeException

Java代码

/**

*RuntimeException:

* Exception中有一个非常特殊子类异常,RuntimeException 运行时异常

* 如果在函数内部使用throw抛出异常,函数上可以不用throws声明,编译一样通过.

* 如果在函数上使用throws声明了该异常,调用者可以不用进行处理,编译一样通过;

*之所以不用在函数上使用throws声明,是因为不需要让调用者处理

*当异常发送,JVM希望程序停止,因为在运行时,出现了无法继续运算的情况,希望停止程序后,然程序员对代码进行修正

*

*自定义异常时,如果该异常的发生,无法在继续进行运算,就让自定义异常继承RuntimeException.

*

*对于异常的分类

*1.编译时被检测的异常 (必须使用 throws 或者 try catch进行处理)

*

*2.编译时不被检测的异常(运行时异常,RuntimeException以及其子类) 程序会停止掉,然后要改进代码

*

*/

class Demo{

static int div(int a,int b){ //发现 这里不需要 throws 怎么回事?

if(b==0)

throw new ArithmeticException("被零除了!"); //需改 java自定义异常中的提示,改成我们熟悉的

return a/b;

}



static int div1(int a,int b)throws ArithmeticException{

//if(b==0)

//throw new Exception("被零除了!"); //需改 java自定义异常中的提示

return a/b;

}



static int div2(int a,int b){ //发现 这里不需要 throws 怎么回事?

if(b<0)

throw new FuShuException("出现除数为负数了"); //需改 java自定义异常中的提示

if(b==0)

throw new ArithmeticException("被零除了!");

return a/b;

}



}

//自定义 运行时异常类

class FuShuException extends RuntimeException{



public FuShuException(String msg) {

super(msg);

}

}



public class ExceptionDemo3 {



public static void main(String[] args) {

// TODO Auto-generated method stub

/*Demo.div(4, 0); //

Demo.div1(4, 0); //发现没有 try catch 编译也通过



Demo.div2(4, -9);*/





//讲课

Teacher t=new Teacher("张老师");

try {

t.prelect();

} catch (NoPlanException e) {

System.out.println(e.toString());

System.out.println("换老师 或者 放假!");

}

}



}





/*

* 老师上课

*

* 思考上课中出现的问题

* 比如问题: 电脑蓝屏

* 电脑冒烟

*

* 要对问题进行封装成对象.

* 冒烟后,出现讲课进度无法继续

* 出现了讲师的问题,课时计划无法完成.

*

* throw 和 return 单独存在的时候,后面不能出现 其他语句

*/

class Teacher{

private String name;



private Computer cmpt;

Teacher(String name){

this.name=name;

this.cmpt=new Computer();

}



public void prelect()throws NoPlanException{

try {

cmpt.run();

} catch (LanPingException e) {

cmpt.reset();

} catch (MaoYanException e) {

test();

throw new NoPlanException("课时无法继续"+e.getMessage());

//test(); //不能放在这里 ,throw 和 return 单独存在的时候,后面不能出现 其他语句

}

System.out.println("讲课");

}



public void test(){

System.out.println("练习!");

}





}

class Computer{

private int status=3;

public void run()throws LanPingException,MaoYanException {

if(status==2)

throw new LanPingException("蓝屏了");

if(status==3)

throw new MaoYanException("冒烟了");



System.out.println("电脑运行");

}

public void reset(){

this.status=1;

System.out.println("电脑重启");

}

}



//封装问题

class LanPingException extends Exception{

LanPingException(String message){

super(message);

}

}



class MaoYanException extends Exception{

MaoYanException(String message){

super(message);

}

}

//冒烟后的异常

class NoPlanException extends Exception{

NoPlanException(String message){

super(message);

}

}

finally

Java代码

/**

* finally代码快:定义一定要执行的代码

* 通常用于关闭资源

* 如果 catch中 有return 的时候 finally 代码会被执行 而其他的代码不会被执行.

*/

class FuShuException extends Exception{

FuShuException(String msg){

super(msg);

}

}



class Demo{

static int div(int a,int b)throws FuShuException{

if(b<0)

throw new FuShuException("除数为负数!");

return a/b;

}

}

class NoException extends Exception{



}

public class FinallyDemo1 {



public static void main(String[] args) {

test1(); // 除数为负数! finally over



test2(); // 除数为负数! finally

}

public static void test1(){

try {

int x=Demo.div(4, -1); //1

System.out.println("x="+x);

} catch (FuShuException e) {

System.out.println(e.toString()); //2

}finally{

System.out.println("finally"); //3

}

System.out.println("over"); //4

}



public static void test2(){

try {

int x=Demo.div(4, -1); //1

System.out.println("x="+x);

} catch (FuShuException e) {

System.out.println(e.toString()); //2

return; // 使用return后 //4

}finally{

System.out.println("finally"); //3

}

System.out.println("over");

}





/**

* 采用分层的思想来设计 一般不会抛出 SQLException 给调用者 而是给一个 调用者能看的懂的异常

*/

public void method()throws /*SQLException*/NoException {

//连接数据库

//数据操作: //throw new SQLException();

//关闭数据库



try {

//连接数据库

//数据操作:

}catch (SQLException e) {

//会对数据库进行异常操作

//throw new SQLException();

throw new NoException();

}finally{

//关闭数据库

}

}



}

Java代码

/**

*

*异常的几种格式

*

*记住一点:catch是用户处理异常,如果没有catch就代表异常没有被处理过,如果该异常是检测时异常,那么使用 throws必须声明.

*/

class ExceptionStyle{

//异常的几种格式

public void method(){

//第一种格式

try {



} catch (Exception e) {

// TODO: handle exception

}



//第二种格式

try {



} catch (Exception e) {

// TODO: handle exception

}finally{



}

//第三格式

try{



}finally{



}



//第四种 格式

try {



}catch (ArithmeticException e) {

// TODO: handle exception

}catch (Exception e) {

// TODO: handle exception

}



}



//看看下面几种情况



//错误 没有throws Exception 编译不通过

public void method1() /*throws Exception*/{

throw new Exception();

}



//正确

public void method2(){

try {

throw new Exception();

} catch (Exception e) {

// TODO: handle exception

}



}



//错误 处理一个异常后 又抛出了异常 编译不通过

public void method3(){

try {

throw new Exception();

} catch (Exception e) {

throw e;

}



}



//正确 只要 e 被处理就可以了

public void method4(){

try {

throw new Exception();

} catch (Exception e) {

try {

throw e;

} catch (Exception e2) {

// TODO: handle exception

}

}



}



//错误 没有catch 或则 throws 就是没有处理 编译 不通过 ,

public void method5(){

try {

throw new Exception();

}finally{

//关闭资源 产生的异常 有调用者处理

}

}



}