黑马程序员技术交流社区

标题: 【记录】代码练习-异常处理 [打印本页]

作者: Kevin.Kang    时间: 2015-7-21 16:18
标题: 【记录】代码练习-异常处理
程序异常:Throwable
        严重问题:Error不作处理,这种问题一般都是很严重的,比如内存溢出
        问题:Exception
                编译期:不是RuntimeException的异常,必须进行处理,不处理,编译不能通过
                运行期:RuntimeException,这种问题不处理,这种问题的出现肯定是代码不够严谨导致,需要修正代码。

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


作者: Kevin.Kang    时间: 2015-7-21 16:20
本帖最后由 Kevin.Kang 于 2015-7-22 12:59 编辑
  1. package com.kxg.exception;

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


  54.                 try {
  55.                         System.out.println(i / j);
  56.                         System.out.println(arr[3]);
  57.                 } catch (ArrayIndexOutOfBoundsException ai) {
  58.                         System.out.println("超出范围");
  59.                 } catch (Exception e) {
  60.                         System.out.println("0不能作除数");
  61.                 }
  62.                 System.out.println("好好学习,天天向上");
  63.         }
  64. }
复制代码

try里面有多个异常代码,只能查找第一个,如果产生了异常,try里面就会自动生成一个异常对象,然后把这个对象抛出,一旦某个catch捕获到匹配的异常类型,将进入异常处理代码。一经处理结束,就意味着整个try-catch语句结束。其他的catch子句不再有匹配和捕获异常类型的机会。
作者: Kevin.Kang    时间: 2015-7-21 17:58
本帖最后由 Kevin.Kang 于 2015-7-21 18:04 编辑

  编译时异常和运行时异常的区别:
                编译期异常:java程序必须显示处理,否则程序就会发生错误,无法通过编译。
                 运行期异常:无需显示处理,也可以和编译时异常一样处理。
编译期异常:
  1. package com.kxg.exception;
  2. import java.text.ParseException;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;

  5. public class ExceptionDemo2 {
  6.         public static void main(String[] args) {
  7.                 String s = "164646464";
  8.                 date2(s);// 方法自己处理了,可以继续往下执行

  9.                 // date(s);//继续抛给main函数,主函数会接着抛给虚拟机,虚拟机做出处理,程序结束。

  10.                 // 调用者自己做出处理,程序会继续往下执行。
  11.                 try {
  12.                         date(s);
  13.                 } catch (ParseException e) {
  14.                         e.printStackTrace();
  15.                 }

  16.                 System.out.println("程序结束");
  17.         }

  18.         // 处理1: 抛出异常,代表这个方法会出现异常,需要调用者进行处理,不然编译不通过。
  19.         public static void date(String s) throws ParseException {
  20.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  21.                 Date d = sdf.parse(s);
  22.                 System.out.println(d);
  23.         }

  24.         // 处理2: 方法处理异常
  25.         public static void date2(String s) {
  26.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
  27.                 Date d = null;
  28.                 try {
  29.                         d = sdf.parse(s);
  30.                 } catch (ParseException e) {
  31.                         System.out.println("解析错误");
  32.                 }
  33.                 System.out.println(d);
  34.         }
  35. }
复制代码







作者: vinoMVP    时间: 2015-7-21 18:03
学习了。。。。
作者: Kevin.Kang    时间: 2015-7-21 18:16
运行期异常:
  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.                 method2();
  13.                 System.out.println("===================");

  14.                 // 方法内部throw抛出异常,方法外部接着抛出,调用者可以处理,也可以继续抛给主方法,不过程序会结束。
  15.                 try {
  16.                         method3();
  17.                 } catch (Exception e) {
  18.                         e.printStackTrace();
  19.                 }
  20.                 System.out.println("===================");

  21.                 // 然并卵?
  22.                 method4();
  23.         }

  24.         // 方法出于某种原因不处理,抛给调用者进行处理。
  25.         public static void method() throws Exception {
  26.                 int a = 1;
  27.                 int b = 0;
  28.                 System.out.println(a / b);
  29.         }

  30.         // 方法自己进行处理,不再抛出
  31.         public static void method2() {
  32.                 int a = 1;
  33.                 int b = 0;
  34.                 try
  35.                 {
  36.                         System.out.println(a / b);
  37.                 } catch (Exception e)
  38.                 {
  39.                         System.out.println("出错");
  40.                 }
  41.         }

  42.         // throw抛出1
  43.         public static void method3() throws Exception {
  44.                 int a = 1;
  45.                 int b = 0;
  46.                 if (b == 0) {
  47.                         throw new Exception();
  48.                 } else {
  49.                         System.out.println(a / b);
  50.                 }
  51.         }

  52.         // throw抛出2
  53.         public static void method4() {
  54.                 int a = 1;
  55.                 int b = 0;
  56.                 if (b == 0) {
  57.                         throw new ArithmeticException();
  58.                 } else {
  59.                         System.out.println(a / b);
  60.                 }
  61.         }
  62. }
复制代码




作者: 小灬清新丶    时间: 2015-7-21 18:49
呵呵,广少好努力啊
作者: Kevin.Kang    时间: 2015-7-22 11:30
throws和throw区别:
throws:
        用在方法声明后面,跟的是异常名
        可以跟多个异常名,用都好隔开
        表示抛出异常,由该方法的调用者处理
        throws表示出现异常的一种可能性,并不一定会发生这些异常
throw:
        用在方法体内,跟的是异常对象名。
        只能抛出一个具体异常对象名
        表示抛出异常,由方法体内的语句处理
        throw表示抛出了异常,执行throw一定抛出了某种异常。


作者: Kevin.Kang    时间: 2015-7-22 15:18
  1. package com.kxg.exception;

  2. import java.text.ParseException;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;

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



作者: Kevin.Kang    时间: 2015-7-22 15:26
final,finally,finalize的区别:
        final:最终的意思。修饰成员变量,成员方法,类
                        修饰成员变量:变量是常量
                        修饰成员方法:不能被重写
                        修饰类:不能被继承
        finally:异常处理的一部分,用于释放资源。
        finalize:Object类中的一个方法,用于垃圾回收。
                同样用于垃圾回收的还有System类下的gc()方法。


作者: Kevin.Kang    时间: 2015-7-22 17:29
try...catch...finally的格式变形:
        try...catch...finally
        try...catch
        try...catch...catch
        try...catch...catch...finally
        try...finally(这种做法是为了释放资源)



作者: Kevin.Kang    时间: 2015-7-23 11:16
自定义异常:
  1. package com.kxg.exception2;

  2. public class MyException extends Exception {
  3.         public MyException() {
  4.         }

  5.         public MyException(String s) {
  6.                 super(s);
  7.         }
  8. }
复制代码
  1. package com.kxg.exception2;

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

  2. import java.util.Scanner;

  3. public class NumberDemo {
  4.         public static void main(String[] args) {
  5.                 Scanner sc = new Scanner(System.in);
  6.                 System.out.println("请输入数字(1-100):");
  7.                 int i = sc.nextInt();

  8.                 Person p = new Person();
  9.                 try {
  10.                         p.check(i);
  11.                 } catch (MyException e) {
  12.                         e.printStackTrace();
  13.                 }
  14.         }
  15. }
复制代码




作者: Kevin.Kang    时间: 2015-7-23 11:25
继承中异常注意事项:
        1.子类重写父类方法时,子类的方法必须抛出和父类相同的异常,或父类异常的子类。
        2.如果父类方法抛出多个异常,子类重写父类方法事,只能抛出相同的异常或者是他的子类。子类不能抛出父类没有的异常。
        3.如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法中有异常产生,那么子类只能try,不能throws。






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