黑马程序员——java---异常问题

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

异常

异常：就是不正常，是指程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这些信息进行封装。异常就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。

 

出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位置，所以可以不断的向上抽取。形成了异常体系。

异常体系的特点：

异常体系中的所有类及其子类对象都具备可抛性。也就是说可以被throw和throws关键字所操作。

异常的体系  Throwable

Error

通常指JVM出现重大问题如：运行的类不存在或者内存溢出等。

不需要编写针对代码对其处理，程序无法处理。

Exception 

在运行时运行出现的一些情况，可以通过try,catch,finally处理

异常处理两种方式：

1、捕获异常：try catch 直接处理可能出现的异常！

2、声明异常：throws 声明告诉调用者可能的异常，暴露问题，调用者自己处理！

我的总结：

Exception 和 Error的子类名大都是以父类名作为后缀。

Java异常其实是对不正常情况的一种描述,并将其封装成对象;

Java在 设计异常体系时，将容易出现的异常情况都封装成了对象。

异常处理格式

 

异常处理的5个关键字

try ,catch,

finally 

throw, throws

我的总结：

捕获异常：先捕获小异常再捕获大异常。

程序是调出来的，不是写出来的；多测试是程序员的必修课。

异常处理后，程序不会因为出现异常而退出!

异常处理格式

try{

//可能出异常的代码

} catch(异常类  对象){

//处理该异常类型的语句

}

[finally] {

//一定会执行的代码

//catch块使用System.exit(1);除外

}

 

备注：当try语句块出现异常，程序会自动跳到catch语句块去找匹配的异常类型，并执行异常处理语句，finally语句块是异常的统一出口。

多异常处理

声明异常时尽可能声明具体异常类型,方便更好的处理;

方法声明几个异常就对应有几个catch块;

若多个catch块中的异常出现继承关系,父类异常catch块放在最后;

在catch语句块使用Exception类作为异常类型时：

所有子类实例都可以使用父类接收(向上转型)，即所有的异常对象都可以使用Exception接收;

注：在java处理多异常时捕获小范围的异常必须放在大范围异常之前。

异常的分类

 

异常分类:

编译时异常：

编译时被检查异常;  ---> Checked异常

在程序中必须使用try...catch处理；

编译时不被检测的异常; ---> Runtime异常

运行时异常：

可以不使用try...catch处理，但一旦出现异常就将由JVM处理

异常的分类之Runtime异常

 

 

RuntimeException(运行时异常)是指因设计或实现方式不当而导致的问题.

说白了,就是程序员造成的,程序员小心谨慎是完全可以避免的异常.比如,事先判断对象是否为null就可以避免NullPointerException异常,事先检查除数不为0就可以避免ArithmeticException异常;

 

特点:

这种异常Java编译器不会检查它,也就说程序中出现这类异常的时候,即使不处理也没有问题,但是一旦出现异常,程序将异常终止,若采用异常处理,则会被相应的程序执行处理.

 

异常的分类之Checked异常

 

除了RuntimeException以及子类,其他的Exception及其子类都是受检查异常,我们也可以称为非RuntimeException异常.

特点:

Java编译器会检查它,也就说程序中一旦出现这类异常,要么是没有try-catch语句捕获,或throws语句没有声明抛出它,编译就不会通过,也就说这种异常,程序要求必须处理.

声明异常（throws）

 

在可能出现异常的方法上声明抛出可能出现异常的类型：

声明的时候尽可能声明具体的异常,方便更好的处理.

当前方法不知道如何处理这种异常，可将该异常交给上一级调用者来处理(非RuntimeException类型的异常)。

方法一旦使用throws声明抛出方法内可能出现的异常类型， 该方法就可以不再过问该异常了；

一个方法调用另一个使用throws声明抛出的方法，自己要么try...catch , 要么也throws;

 

格式：

public 返回值类型  方法名(参数列表...) 

throws 异常类A,异常类B... {

}

throw

自行抛出一个异常对象，抛出异常类的对象；

若throw抛出的是Runtime异常：

程序可以显示使用try...catch来捕获并处理，也可以不管，直接交给方法调用者处理；

若throw抛出Checked异常：

要么放在try里自己处理，要么放在一个throws声明的方法里面，交给调用者处理。

 

Eg：

public static void main(String[] args) {try {      fn1(1);} catch (Exception e) { e.printStackTrace(); }fn2(2);}public static void fn1(int a) throws Exception{if(a >0) { throw new Exception("fn1 -- a值不合法"); }}public static void fn2(int a) {if(a >0) { throw new RuntimeException("a值不合法"); }}

 

throws & throw

 

throws用于在方法上声明该方法需要处理的异常类型。

throw用于抛出具体异常类的对象。

throws与throw的区别：

thorws用在方法上，后面跟异常类名,可以是多个异常类。

throw用在方法内，后面跟异常对象,只能是一个。

finally

 

异常的统一出口：

不管try块程序是否异常，也不管哪个catch执行，finally块总会执行。

try语句块或会执行的catch语句块使用了JVM系统退出语句例外;//System.exit(1);

try块必须和 catch块或和finally同在，不能单独存在，二者必须出现一个。

不要在finally中使用return 或throw语句，否则将会导致try、catch中的return或throw失效。

 

我的总结：finally代码块只在一种情况下不执行：System.exit(0)；

自定义异常

定义类继承Exception或者RuntimeException

1,为了让该自定义类具备可抛性。

2，让该类具备操作异常的共性方法。

class MyExcepiton extends Exception{MyExcepiton(){} MyExcepiton(String message){super(message);}} class MyException extends RuntimeException{MyExcepiton(){} MyExcepiton(String message){super(message);}}

 

异常的好处：

1、将问题进行了封装。

2、将正常流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：

1、处理方式有两种：try或者throws。

2、调用到抛出异常的功能时，抛出几个，就处理几个。一个try可以对应多个catch。

3、多个catch，父类的catch放在最下面。

4、Catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。

也不要不写。

当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

Try{Throw new AException();}catch(AException e){Throw e;}

 

如果该异常处理不了，但并不属于该功能出现的异常。

可以将异常转换后，在抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去。

让调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。

Try{Throw new AException();}catch(AException e){Throw new  BException();//对AException处理。}

 

异常也是一个对象，在程序中碰到问题就用异常。

异常的注意事项：

在子父类覆盖时：

1、子类抛出的异常必须是父类的异常的子类或者子集。

2、如果父类或者接口没有异常抛出时，子类覆盖出现异常，，只能try不能抛。

Finally

不管try块程序是否异常，也不管哪个catch执行，finally块总会执行。

前面售票的例子锁的释放问题就用到了，

示例：

import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;class Tick implements Runnable{private int tick = 100;//Object obj = new Object();Lock lock = new ReentrantLock();Condition condition = lock.newCondition();@Overridepublic void run() {// TODO Auto-generated method stub//int count = 0;while(true){lock.lock();try{//synchronized (obj) {if(tick>0){try {Thread.sleep(100);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}System.out.println(Thread.currentThread().getName()+"...卖出了："+(tick--)+"号票");}}finally{lock.unlock();//不管前面有没有异常处没处理都要释放锁}}}//}}public class DeMo7 {/** * @param args */public static void main(String[] args) {// TODO Auto-generated method stubTick tk = new Tick();Thread t1 = new Thread(tk);Thread t2 = new Thread(tk);Thread t3 = new Thread(tk);t1.start();t2.start();t3.start();}}