黑马程序员技术交流社区

标题: 异常总结第一篇 [打印本页]

作者: a80C51    时间: 2015-9-13 23:39
标题: 异常总结第一篇
1,定义:程序运行时出现的不正常情况。
2,由来:问题通过java的类的形式进行描述,并封装成对象。
3,问题的划分
        1)严重的:使用Error类描述,对Error一般不编写针对性的处理方式。
        2)不严重:用Exception类进行描述,需要针对性的处理方式。
        其中,Exception类还可以细分为
                a,Checked异常——在编译阶段被处理的异常;
                b,Runtime异常——无须处理。
4,异常处理
        1)语法结构
  1.                 try
  2.                 {//这对花括号,不能被省略。
  3.                         需要被检测的代码;
  4.                 }
  5.                 catch(异常类 变量)
  6.                 {//这对花括号,不能被省略。
  7.                         处理异常的代码(处理方式);
  8.                 }
  9.                 finally
  10.                 {//这对花括号,不能被省略。
  11.                         一定会执行的语句;
  12.                         故该块保证一定能回收try块中打开的物理资源。
  13.                 }
复制代码

        2)三者的关系
                a,没有try块,则没有catch/finally代码块;
                b,catch块和finally块可选,但必须出现其中的某一个;
                c,有多个catch块时,捕捉父类异常的catch块必须位于捕捉子类异常的后面;
                d,多个catch块必须位于try块之后,finally块必须位于所有的catch块之后。
        3)try块中的变量是代码局部变量,catch无法访问。
        4)对异常对象操作的方法:
                a,getMessage()//获取异常的信息;
                b,toString()//异常名称:异常信息;
                c,void printStackTrace()//异常名称:异常信息:异常出现的位置;
                d,printStackTrace(PrintStream s)//将信息输出到指定的输出流中.
5,对多异常的处理
        1)原则
                a,声明异常是,建议声明更为具体的异常;
                b,对方声明几个异常,就有几个catch块,不能有多的;
                c,父类的catch块放在最下面;
                d,在进行catch处理时,catch块中,一定要有具体的处理方式,不要简单的打印或者仅使用printStackTrace()方法。
        2)Java7之后支持一个catch块中捕捉多种异常。
                注意事项:
                a,捕获多种类型的异常时,多种异常类型之间用竖线(|)隔开;
                b,捕获多种类型的异常时,异常变量有隐式的final修饰,因此程序不能对异常变量重新赋值。
代码实例如下
  1. public class myException
  2. {
  3.         public static void main(String[] args)
  4.         {
  5.                 try
  6.                 {//这对花括号,不能被省略。
  7.                         //需要被检测的代码;
  8.                         int a = Integer.parseInt(args[0]);
  9.                         int b = Integer.parseInt(args[1]);
  10.                         int c = a / b;
  11.                         System.out.println("您输入的两个数据相除的结果是:"+c);
  12.                 }
  13.                 /*//java7之前的表达方法
  14.                 catch (IndexOutOfBoundsException ie)
  15.                 {//这对花括号,不能被省略。
  16.                         //处理异常的代码(处理方式);
  17.                         System.out.println("数组越界:运行时输入的参数个数不够!");
  18.                         //获取异常的信息;
  19.                         System.out.println(ie.getMessage());
  20.                         //try块中的变量是代码局部变量,catch无法访问。
  21.                         //下面这句话将报错。
  22.                         //System.out.println("系统的被除数是:"+a);
  23.                 }
  24.                 catch (NumberFormatException ne)
  25.                 {//这对花括号,不能被省略。
  26.                         //处理异常的代码(处理方式);
  27.                         System.out.println("数字格式异常:程序只能接收整型参数");
  28.                         //获取异常的信息;
  29.                         System.out.println(ne.toString());
  30.                 }
  31.                 catch (ArithmeticException ae)
  32.                 {//这对花括号,不能被省略。
  33.                         //处理异常的代码(处理方式);
  34.                         System.out.println("算数异常");
  35.                         ae.printStackTrace();//异常名称:异常信息:异常出现的位置;
  36.                 }
  37.                 catch (Exception e)
  38.                 {//这对花括号,不能被省略。
  39.                         //处理异常的代码(处理方式);
  40.                         System.out.println("未知异常");
  41.                 }
  42.                 */
  43.                 //java7之后的表达方式
  44.                 catch (IndexOutOfBoundsException|NumberFormatException|ArithmeticException e)
  45.                 {
  46.                         System.out.println("系统发生了如下异常中的某一个");
  47.                         System.out.println("算数异常、数组越界、数字格式异常");
  48.                        
  49.                         //捕获多种类型的异常时,异常变量有隐式的final修饰,因此程序不能对异常变量重新赋值。
  50.                         //故如下语句会引起异常
  51.                         //e = new RuntimeException("text");
  52.                 }
  53.                 finally
  54.                 {//这对花括号,不能被省略。
  55.                         //一定会执行的语句;
  56.                         System.out.println("这个程序结束了!");
  57.                 }
  58.         }
  59. }
复制代码

6,Java7中try语句支持自动关闭资源
        1)注意点:该资源必须实现AutoCloseable或者Closeable接口。
        2)格式:
  1.                 try(需要自动关闭资源的语句)
  2.                 {//这对花括号,不能被省略。
  3.                         需要被检测的代码;
  4.                 }
复制代码

7,Checked异常
        1)处理方式
                a,当前方法明确知道如何处理,程序使用try……catch来捕获异常,然后在对应的catch块中修复该异常。
                b,当前方法不知道如何处理这种异常,应该在定义该方法时声明抛出异常。
        2)可以利用throws声明抛出异常。
        3)不便之处
                a,程序中的Checked异常,Java要求必须显示捕获并处理该异常,或者显示声明抛出该异常。增加了编程复杂度;
                b,如果在方法中显示声明抛出Checked异常,将会导致方法签名与异常耦合,如果方法时重写父类的方法,则该方法抛出的异常还会受到被重写方法所抛出异常的限制。
8,Runtime异常(还未整理)
9,throw和throws的区别
        1)位置不同
        throws出现在方法签名上,也就是形参括号的结尾到方法体开始的大括号之前;
        throw出现在方法内
        2)后面跟的内容不同
        throws后面跟的是异常类,可以跟多个,用逗号隔开;
        throw后面跟的是异常对象。
        3)当方法内部出现throw抛出异常对象,那么就必须要给出相应的处理动作
                方式一,在内部try catch处理
                方式二,在方法上通过throws声明,让调用者处理。
10,自定义异常类
        1)要求
                a,用户自定义异常都应该继承Exception基类,如果希望自定义Runtime异常,则应继承RuntimeException基类;
                b,需要提供两个构造器:无参数构造器和带一个字符串参数的构造器。
        2)继承Exception的原因
                异常体系有一个特点,异常类和异常对象都可以被抛出,他们具有可抛性。这个是Throwable类独有的特点,只有Exception这个体系中的类和对象才可以被throw和throws所操作。
代码实例如下:
  1. class myOwnException extends Exception
  2. {
  3.         private String msg;
  4.         private int valueExcept;
  5.        
  6.         //无参数构造器
  7.         public myOwnException(){}
  8.         //带一个字符参数的构造器
  9.         public myOwnException(String msg)
  10.         {
  11.                 super(msg);
  12.         }
  13.         //带其他参数的构造器
  14.         public myOwnException(String msg,int valueExcept)
  15.         {
  16.                 super(msg);
  17.                 this.valueExcept = valueExcept;
  18.         }
  19.        
  20.         public int getExceptValue()
  21.         {
  22.                 return valueExcept;
  23.         }
  24. }

  25. class Demo
  26. {
  27.         public int div(int a,int b)throws myOwnException//方式二,在方法上通过throws声明,让调用者处理。
  28.         {
  29.                 if(b<0)
  30.                 //当方法内部出现throw抛出异常对象,那么就必须要给出相应的处理动作
  31.                         throw new myOwnException("传入负数",b);
  32.                        
  33.                 return a/b;
  34.         }
  35. }

  36. public class myOwnerException
  37. {
  38.         public static void main(String[] args)
  39.         {
  40.                 Demo d = new Demo();
  41.                 int result = 0;
  42.                
  43.                 try
  44.                 {
  45.                         result = d.div(4,-1);
  46.                         System.out.println("the result is "+result);
  47.                 }
  48.                 catch (myOwnException e)
  49.                 {
  50.                         System.out.println(e.toString());
  51.                         System.out.println("错误的数字是:"+e.getExceptValue());
  52.                 }
  53.                 finally
  54.                 {
  55.                         System.out.println("It is over!!!");
  56.                 }
  57.         }
  58. }
复制代码

作者: a80C51    时间: 2015-9-15 22:11
为了不破坏整体效果,重新回复并补充Runtime异常
8,Runtime异常
        1)特点:
                a,如果在方法内部抛出异常,方法签名上可以不用声明,编译一样通过;
                b,如果在方法上声明了该异常,调用者可以不用处理,编译一样通过。
        2)不用声明的原因:
        无需调用者处理,当该异常发生,希望程序停止,因为在运行时,出现了无法继续运算的情况,希望停止程序后,由程序员去完善。
        3)对于自定义异常,如果判定该异常发生时,程序无法运行,则需要继承Runtime异常。

作者: 笑笑精灵    时间: 2015-9-15 22:26
嗯,看过。顶一下
作者: 天涯莫名    时间: 2015-9-15 22:32
路过,顶一下
作者: heimatai6    时间: 2015-9-16 00:04
蒙圈、、、、、
作者: kenfans    时间: 2015-9-16 00:13
帮顶一下




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2