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. 
    
26. class Demo
    
27. {
    
28.         public int div(int a,int b)throws myOwnException//方式二，在方法上通过throws声明，让调用者处理。
    
29.         {
    
30.                 if(b<0)
    
31.                 //当方法内部出现throw抛出异常对象，那么就必须要给出相应的处理动作
    
32.                         throw new myOwnException("传入负数",b);
    
33.                        
    
34.                 return a/b;
    
35.         }
    
36. }
    
37. 
    
38. public class myOwnerException
    
39. {
    
40.         public static void main(String[] args)
    
41.         {
    
42.                 Demo d = new Demo();
    
43.                 int result = 0;
    
44.                
    
45.                 try
    
46.                 {
    
47.                         result = d.div(4,-1);
    
48.                         System.out.println("the result is "+result);
    
49.                 }
    
50.                 catch (myOwnException e)
    
51.                 {
    
52.                         System.out.println(e.toString());
    
53.                         System.out.println("错误的数字是："+e.getExceptValue());
    
54.                 }
    
55.                 finally
    
56.                 {
    
57.                         System.out.println("It is over！！！");
    
58.                 }
    
59.         }
    
60. }

复制代码

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

嗯，看过。顶一下

路过,顶一下

蒙圈、、、、、

帮顶一下