程序异常：Throwable
        严重问题：Error不作处理，这种问题一般都是很严重的，比如内存溢出
        问题：Exception
                编译期：不是RuntimeException的异常，必须进行处理，不处理，编译不能通过
                运行期：RuntimeException，这种问题不处理，这种问题的出现肯定是代码不够严谨导致，需要修正代码。

        程序如果出现问题，而我们没有做任何处理，最终JVM会做出默认的处理。
        把异常名称，原因和出现的问题等信息输出在控制台。同时结束程序，后面的不再执行。

1. package com.kxg.exception;
   
2. 
   
3. /*
   
4. * 自己处理异常：
   
5. *                 try...catch..finally
   
6. *                 throws 抛出
   
7. *
   
8. * try...catch...finally格式：
   
9. *         格式1：
   
10. *                 try{
    
11. *                         可能出现问题的代码;
    
12. *                 }catch(异常名 变量){
    
13. *                         问题的处理;        
    
14. *                 }finally{
    
15. *                 释放资源;
    
16. *                 }
    
17. *         格式2：
    
18. *                 try{
    
19. *                         可能出现问题的代码;
    
20. *                 }catch(异常名 变量){
    
21. *                         问题的处理;        
    
22. *                 }
    
23. *         格式3：
    
24. *                 try{
    
25. *                         可能出现问题的代码;
    
26. *                 }catch(异常名 变量){
    
27. *                         问题的处理;        
    
28. *                 }catch(异常名 变量){
    
29. *                         问题的处理;        
    
30. *                 }
    
31. * 格式4：JDK7的新异常处理方案
    
32. *                try{
    
33. *                         可能出现问题的代码;
    
34. *                 }catch(异常名1|异常名2|...变量){
    
35. *                         问题的处理;        
    
36. *                 }
    
37. *                 缺点：
    
38. *                         处理方法是一致的
    
39. *                         多个异常必须是平级关系
    
40. *
    
41. * 注意：
    
42. *                 try里面的代码越少越好。
    
43. *                 catch里面必须有内容。
    
44. *                 处理多个异常：
    
45. *                         能够明确异常名的尽量明确，不要用捕获大范围的异常
    
46. *                         实在不明确的异常可以使用大范围的，必须放到最后位置，平级关系无所谓。
    
47. *                        
    
48. *
    
49. */
    
50. public class ExceptionDemo {
    
51.         public static void main(String[] args) {
    
52.                 int i = 10;
    
53.                 int j = 0;
    
54.                 int[] arr = new int[3];
    
55. 
    
56. 
    
57.                 try {
    
58.                         System.out.println(i / j);
    
59.                         System.out.println(arr[3]);
    
60.                 } catch (ArrayIndexOutOfBoundsException ai) {
    
61.                         System.out.println("超出范围");
    
62.                 } catch (Exception e) {
    
63.                         System.out.println("0不能作除数");
    
64.                 }
    
65.                 System.out.println("好好学习，天天向上");
    
66.         }
    
67. }

复制代码

try里面有多个异常代码，只能查找第一个，如果产生了异常，try里面就会自动生成一个异常对象，然后把这个对象抛出，一旦某个catch捕获到匹配的异常类型，将进入异常处理代码。一经处理结束，就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。

  编译时异常和运行时异常的区别：
                编译期异常：java程序必须显示处理，否则程序就会发生错误，无法通过编译。
                 运行期异常：无需显示处理，也可以和编译时异常一样处理。
编译期异常：

1. package com.kxg.exception;
   
2. import java.text.ParseException;
   
3. import java.text.SimpleDateFormat;
   
4. import java.util.Date;
   
5. 
   
6. public class ExceptionDemo2 {
   
7.         public static void main(String[] args) {
   
8.                 String s = "164646464";
   
9.                 date2(s);// 方法自己处理了，可以继续往下执行
   
10. 
    
11.                 // date(s);//继续抛给main函数，主函数会接着抛给虚拟机，虚拟机做出处理，程序结束。
    
12. 
    
13.                 // 调用者自己做出处理，程序会继续往下执行。
    
14.                 try {
    
15.                         date(s);
    
16.                 } catch (ParseException e) {
    
17.                         e.printStackTrace();
    
18.                 }
    
19. 
    
20.                 System.out.println("程序结束");
    
21.         }
    
22. 
    
23.         // 处理1： 抛出异常，代表这个方法会出现异常，需要调用者进行处理，不然编译不通过。
    
24.         public static void date(String s) throws ParseException {
    
25.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    
26.                 Date d = sdf.parse(s);
    
27.                 System.out.println(d);
    
28.         }
    
29. 
    
30.         // 处理2： 方法处理异常
    
31.         public static void date2(String s) {
    
32.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    
33.                 Date d = null;
    
34.                 try {
    
35.                         d = sdf.parse(s);
    
36.                 } catch (ParseException e) {
    
37.                         System.out.println("解析错误");
    
38.                 }
    
39.                 System.out.println(d);
    
40.         }
    
41. }
    

复制代码

学习了。。。。

运行期异常：

1. package csdn.test;
   
2. public class Test {
   
3.         public static void main(String[] args) {
   
4.                 // 方法抛出异常，调用者进行处理
   
5.                 try {
   
6.                         method();
   
7.                 } catch (Exception e) {
   
8.                         e.printStackTrace();
   
9.                 }
   
10.                 System.out.println("===================");
    
11. 
    
12.                 // 不用处理，方法做过处理
    
13.                 method2();
    
14.                 System.out.println("===================");
    
15. 
    
16.                 // 方法内部throw抛出异常，方法外部接着抛出，调用者可以处理，也可以继续抛给主方法，不过程序会结束。
    
17.                 try {
    
18.                         method3();
    
19.                 } catch (Exception e) {
    
20.                         e.printStackTrace();
    
21.                 }
    
22.                 System.out.println("===================");
    
23. 
    
24.                 // 然并卵？
    
25.                 method4();
    
26.         }
    
27. 
    
28.         // 方法出于某种原因不处理，抛给调用者进行处理。
    
29.         public static void method() throws Exception {
    
30.                 int a = 1;
    
31.                 int b = 0;
    
32.                 System.out.println(a / b);
    
33.         }
    
34. 
    
35.         // 方法自己进行处理，不再抛出
    
36.         public static void method2() {
    
37.                 int a = 1;
    
38.                 int b = 0;
    
39.                 try
    
40.                 {
    
41.                         System.out.println(a / b);
    
42.                 } catch (Exception e)
    
43.                 {
    
44.                         System.out.println("出错");
    
45.                 }
    
46.         }
    
47. 
    
48.         // throw抛出1
    
49.         public static void method3() throws Exception {
    
50.                 int a = 1;
    
51.                 int b = 0;
    
52.                 if (b == 0) {
    
53.                         throw new Exception();
    
54.                 } else {
    
55.                         System.out.println(a / b);
    
56.                 }
    
57.         }
    
58. 
    
59.         // throw抛出2
    
60.         public static void method4() {
    
61.                 int a = 1;
    
62.                 int b = 0;
    
63.                 if (b == 0) {
    
64.                         throw new ArithmeticException();
    
65.                 } else {
    
66.                         System.out.println(a / b);
    
67.                 }
    
68.         }
    
69. }

复制代码

呵呵，广少好努力啊

throws和throw区别：
throws:
        用在方法声明后面，跟的是异常名
        可以跟多个异常名，用都好隔开
        表示抛出异常，由该方法的调用者处理
        throws表示出现异常的一种可能性，并不一定会发生这些异常
throw：
        用在方法体内，跟的是异常对象名。
        只能抛出一个具体异常对象名
        表示抛出异常，由方法体内的语句处理
        throw表示抛出了异常，执行throw一定抛出了某种异常。

1. package com.kxg.exception;
   
2. 
   
3. import java.text.ParseException;
   
4. import java.text.SimpleDateFormat;
   
5. import java.util.Date;
   
6. 
   
7. /*
   
8. * finally:被finally控制的语句体一定会执行
   
9. *
   
10. *         格式
    
11. *                 try...catch...finally
    
12. *         作用：
    
13. *                 用于释放资源，在IO流操作和数据库操作中会见到
    
14. */
    
15. public class FinallyDemo {
    
16.         public static void main(String[] args) {
    
17.                 String s = "1992-02-27";
    
18.                 SimpleDateFormat sdf = new SimpleDateFormat("yyy-MM-dd MM:hh:ss");
    
19.                 try {
    
20.                         Date d = sdf.parse(s);
    
21.                 } catch (ParseException e) {
    
22.                         e.printStackTrace();
    
23.                 } finally {
    
24.                         System.out.println("finally控制语句");
    
25.                 }
    
26.         }
    
27. }

复制代码

final,finally,finalize的区别：
        final：最终的意思。修饰成员变量，成员方法，类
                        修饰成员变量：变量是常量
                        修饰成员方法：不能被重写
                        修饰类：不能被继承
        finally：异常处理的一部分，用于释放资源。
        finalize：Object类中的一个方法，用于垃圾回收。
                同样用于垃圾回收的还有System类下的gc()方法。

try...catch...finally的格式变形：
        try...catch...finally
        try...catch
        try...catch...catch
        try...catch...catch...finally
        try...finally(这种做法是为了释放资源)

自定义异常：

1. package com.kxg.exception2;
   
2. 
   
3. public class MyException extends Exception {
   
4.         public MyException() {
   
5.         }
   
6. 
   
7.         public MyException(String s) {
   
8.                 super(s);
   
9.         }
   
10. }

复制代码

1. package com.kxg.exception2;
   
2. 
   
3. public class Person {
   
4.         public void check(int i) throws MyException {
   
5.                 if (i > 100 || i < 0) {
   
6.                         throw new MyException("数据有误");
   
7.                 } else {
   
8.                         System.out.println("数据无误");
   
9.                 }
   
10.         }
    
11. }

复制代码

1. package com.kxg.exception2;
   
2. 
   
3. import java.util.Scanner;
   
4. 
   
5. public class NumberDemo {
   
6.         public static void main(String[] args) {
   
7.                 Scanner sc = new Scanner(System.in);
   
8.                 System.out.println("请输入数字(1-100)：");
   
9.                 int i = sc.nextInt();
   
10. 
    
11.                 Person p = new Person();
    
12.                 try {
    
13.                         p.check(i);
    
14.                 } catch (MyException e) {
    
15.                         e.printStackTrace();
    
16.                 }
    
17.         }
    
18. }

复制代码

继承中异常注意事项：
        1.子类重写父类方法时，子类的方法必须抛出和父类相同的异常，或父类异常的子类。
        2.如果父类方法抛出多个异常，子类重写父类方法事，只能抛出相同的异常或者是他的子类。子类不能抛出父类没有的异常。
        3.如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，如果子类方法中有异常产生，那么子类只能try，不能throws。