A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 李培根 金牌黑马   /  2012-11-30 21:24  /  1604 人查看  /  3 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

异常:是在运行时期发生的不正常情况。
在java中用于类的形式对不正常情况进行了描述和封装对象。
描述不正常的情况的类,就称为异常类。
以前叫做正常流程代码和问题处理代码相结合。
现在讲正常流程代码和问题处理代码分离,提高阅读性。
其实异常就是java通过面向对象的思想将问题封装成了对象,用异常类对其进行了描述。
不同的问题用不同的类进行具体的描述,比如角标越界、空指针等。
问题很多,意味着描述的类也很多,将其共性向上抽取就形成了异常体系。
最终问题(不正常情况)就分成了两大类。
Throwable:无论是error还是异常都是问题,问题发生就应该可以抛出,让调用者知道并处理。
                该体系的特点就在于        Throwable及其所有的子类都具有可抛性。
                可抛性到底指什么呢?   怎么体现可抛性呢?
                其实就是通过两个关键字来体现的。
                throws和throw,凡是可以被这两个关键字所操作的类和对象都具备可抛性。  
   
|---1、一般不可处理的。error
                        特点:是由jvm抛出的严重性的问题,。
                        这种问题发生一般不针对性处理,直接修改程序。                       
|---2、可以处理的。exception
                       
该体系的特点:
                子类的后缀名都是用其父类名作为后缀,阅读性很强。
异常对象的抛出:
class Demo{
        public int method(int[]arr,int index){
                if(arr==null)
                        throw new NullPointerException("数组的引用不能为空!");
                if(index >= arr.length)
                        throw new ArrayIndexOutOfBoundsException("数组的交表越界啦,哥们你是不是疯了:"+index);
                if(index<0)
                        throw new ArrayIndexOutOfBoundsException("数组的角标不能为负数:"+index);
                return arr[index];
        }
}
class ExceptionDemo{
        public static void main(String[] args){
                int[] arr = new int[3];               
                Demo d = new Demo();
                int num = d.method(arr, 4);
        }
}
-----------------------------------------------------
自定义异常的抛出,throws
对于角标时正数不存在,可以用角标越界表示。
对于负数为角标的情况,准备用负数角标异常来表示。
负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想,面向对象将负数角标进行自定义描述。并封装成对象。
这种自定义的问题描述成为自定义异常。
注意:如果让一个类成为异常类,必须要继承异常依稀,因为只有成为异常体系的子类,才有资格具备可抛性。
才可以被两个关键字所操作,throws  throw
如果
java编译器先检查语法错误,然后检查基本的逻辑错误。
class FuShuIndexException extends Exception{
        FuShuIndexException(){}
        FuShuIndexException(String msg){
                super(msg);
        }
       
}
class Demo{
        public int method(int[] arr,int index)throws FuShuIndexException{
                if(index<0)
                        throw new FuShuIndexException("角标不能为负数");
                return arr[index];
        }
}
public class ExceptionDemo {
        public static void main(String[] args) throws FuShuIndexException {               
                int[] arr = new int[3];
               
                Demo d = new Demo();
                int num = d.method(arr, -2);
        }
}
-----------------------------------------------------
编译时检测异常和运行时异常的区别
异常的分类
1.编译时被检测异常:只要是Exception和其子类都是,除了特殊子类RuntimeException
                这种问题一旦出现,希望在编译时就进行检测,让这种问题有对应的处理方式。
                这样的问题都可以针对性的处理。
2.编译时不检测异常(运行时异常RuntimeException):就是Exception中的RuntimeException和其子类。
                这种问题的发生,无法让功能继续,运算无法进行,更多是因为调用者的原因导致的,或者引发了内部状态的改变导致的。
                这种问题一般不处理,直接编译通过,在运行时,让调用者调用时的程序强制停止。让调用者对代码进行修正。
RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类。               
所以自定义异常是要么继承Exception要么继承RuntimeException.
throws和throw的区别。
1.throws使用在函数上,throw使用在函数内。
2.throws抛出的是异常类,可以抛多个,中间用逗号隔开。throw抛出的是异常对象。
-----------------------------------------------------
异常捕捉 try catch
这是可以对异常进行针对性处理的方式。
具体格式是:
try{
        //需要被检测异常的代码。
}
catch(异常类  变量){//该变量用于接收发生的异常对象
        //处理异常的代码。
}
finally{
        //一定会被执行的代码。
}
如果问题能处理就try catch 不能处理就throws
class FuShuIndexException extends Exception{
        FuShuIndexException(){}
        FuShuIndexException(String msg){
                super(msg);
        }
       
}
class Demo{
        public int method(int[] arr,int index)throws FuShuIndexException{
                if(index<0)
                        throw new FuShuIndexException("角标不能为负数");
                return arr[index];
        }
}
public class ExceptionDemo {
        public static void main(String[] args){               
                int[] arr = new int[3];               
                Demo d = new Demo();
                try {
                        int num = d.method(arr, -2);
                } catch (FuShuIndexException e) {//抛什么就catch什么
                        System.out.println("message:"+e.getMessage());
                        System.out.println(e);
                        e.getStackTrace();//虚拟机的默认异常处理机制。
                        System.out.println("负数角标异常!!!");
                }
                System.out.println("over");//程序可以继续运行。
        }
}
打印结果:
message:角标不能为负数
负数角标异常!!!
over

多catch情况。
class FuShuIndexException extends Exception{
        FuShuIndexException(){}
        FuShuIndexException(String msg){
                super(msg);
        }
       
}
class Demo{
        public int method(int[] arr,int index)throws FuShuIndexException{
                if(arr==null)
                        throw new NullPointerException("没有任何数组实体");
               
                if(index<0)
                        throw new FuShuIndexException("角标不能为负数");
               
                return arr[index];
        }
}
public class ExceptionDemo {
        public static void main(String[] args){               
                int[] arr = new int[3];               
                Demo d = new Demo();
                try {
                        int num = d.method(null, -2);
                }
                catch (NullPointerException e){
                        System.out.println(e.toString());
                }
                catch (FuShuIndexException e) {                       
                        System.out.println(e.toString());                       
                }
                catch(Exception e){//多catch情况,存在父类catch情况,一定要把父类放在最下面。
         
                }
                System.out.println("over");//程序可以继续运行。
        }
}

评分

参与人数 1技术分 +1 收起 理由
古银平 + 1 写日志总结保存吧

查看全部评分

3 个回复

倒序浏览
异常处理的原则:
1.函数内部如果抛出需要检测到的异常,那么函数上必须要声明。
  否则必须在函数内用try catch,否则编译失败。

2.如果调用到了声明异常的函数,要么try catch要么throws,否则编译失败。

3.什么时候catch什么时候throw呢?
        功能内部可以解决,用catch。解决不了用throws告诉调用者,由调用者解决。
       
4.一个功能如果抛出了多个异常,那么调用时,必须有对应多个catch进行针对性的处理。
内部有几个需要检测的异常就抛几个异常,抛出几个就catch几个。

异常  finally代码块


class Demo{
        public int show(int index){
                if(index<0)
                        throw new ArrayIndexOutOfBoundsException("角标越界啦");
                int[] arr = new int[3];
                return arr[index];
        }
}

class ExceptionDemo{
        public static void main(String[] args){
                Demo d = new Demo();
                try{
                        int num = d.show(-1);
                        System.out.println(num);
                }
                catch(ArrayIndexOutOfBoundsException e){
                        System.out.println(e.toString());
                        //System.exit(0);退出jvm
                }
                finally{//一定会执行的代码。通常用于关闭(释放)资源。
                        System.out.println("finally");
                }
                System.out.println("over");
        }
}
//连接数据库
//查询。
//关闭连接。

try catch finally 代码块组合特点:
1.try catch finally
2.try catch(多个) 当没有必要资源需要释放时,可以不定义finally
3.rty finally:异常无法直接catch处理,但是资源需要关闭。

没catch就没处理,没catch就要声明。
void show() throws Exception{
        try{
//                开启资源
                throw new Exception();
               
        }
        finally{
//                关闭资源
        }
}

------------------------------------------------------
异常应用:异常转换

毕老师用电脑上课。

问题领域中涉及两个对象。
毕老师,电脑。
可能会出现的问题。
比如电脑蓝屏啦,冒烟啦。



class LanPingException extends Exception{
        LanPingException(String msg){
                super(msg);
        }
}

class MaoYanException extends Exception{
        MaoYanException(String msg){
                super(msg);
        }
}

class NoPlanException extends Exception{
        NoPlanException(String msg){
                super(msg);
        }
}

class Computer {
        private int state = 0;
        public void run()throws LanPingException,MaoYanException{
                if(state ==1)
                        throw new LanPingException("电脑蓝屏啦");
                if(state ==2)
                        throw new MaoYanException("电脑冒烟啦");
                System.out.println("电脑运行");
        }
        public void reset(){
                state = 0;
                System.out.println("电脑重启");
        }
}

class Teacher{
        private String name;
        private Computer comp;
        Teacher(String name){
                this.name = name;
                comp = new Computer();
        }
        public void prelect()throws NoPlanException{
                try {
                        comp.run();
                        System.out.println(name+"讲课");
                } catch (LanPingException e) {                       
                        System.out.println(e.toString());
                        comp.reset();
                        prelect();
                } catch (MaoYanException e) {                         
                        System.out.println(e.toString());
                        test();
                        //可以对电脑进行维修
//                        throw e;
                        throw new NoPlanException("课时无法完成");
                }
                System.out.println("讲课");
        }
        public void test(){
                System.out.println("大家练习");
        }
}

class ExceptionTest{
        public static void main(String[] args){
                Teacher t = new Teacher("毕老师");
                try {
                        t.prelect();
                } catch (NoPlanException e) {                       
                        System.out.println(".....");
                }
        }
}

异常的转换。没有必要暴露的异常就不要暴露出去。
class NoAddException extendsException{}

void addData(Data d)throws NoAddException{
        连接数据库
        try{
                添加数据。出现异常 SQLException();               
        }
        catch(SQLException e){
                //处理代码。
                throw new NoAddException();
        }
        finally{
                //关闭数据库。
        }
}

-----------------------------------------------------
异常的注意事项。
1.子类在覆盖父类方法时,父类的方法如果抛出了异常,那么子类的方法只能抛出父类的异常或者该异常的子类。
2.如果父类抛出多个异常,那么子类只能抛出父类异常的子集。
简单说:子类覆盖父类只能抛出父类的异常或者其异常子类或者子集。

注意:如果父类的方法没有抛出异常,那么子类覆盖时绝对不能抛。就只能try。
class A extends Exception{}
class B extends A{}
class C extends Exception{}
Exception

        |--A
                |--B
        |--C

class Fu{
        void show() throws A{}
}

class Zi extends Fu{
        void show(){//只能抛出A异常或者B异常。或者不抛异常               
        }
}
回复 使用道具 举报
支持,值得学习!
回复 使用道具 举报
不错,总结的很好,谢了
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马