Java中关于异常的笔记__转载于简书

时间：2020-02-20 20:15:27 阅读：64 评论：0 收藏：0 [点我收藏+]

简书作者：

技术分享图片

原文链接：https://www.jianshu.com/p/66ca87a6d9a1

异常的概述

异常概述
- 异常就是Java程序在运行过程中出现的错误。
由来
- 问题也是现实生活中一个具体事务，也可以通过java 的类的形式进行描述，并封装成对象。
- 其实就是Java对不正常情况进行描述后的对象体现。

异常的分类图解：

从上面的图我们可以看到：程序的异常Throwable分为两类

程序的异常：Throwable
- 严重问题：Error 我们不处理。这种问题一般都是很严重的，比如说内存溢出。
- 问题：Exception
  - 编译期问题:不是RuntimeException的异常必须进行处理的，因为你不处理，编译就不能通过。
  - 运行期问题:RuntimeException 这种问题我们也不处理，因为是你的问题，而且这个问题出现肯定是我们的代码不够严谨，需要修正代码的。

如果程序出现了问题，我们没有做任何处理，最终jvm会做出默认的处理。
把异常的名称，原因及出现的问题等信息输出在控制台。

我们运行程序，可以看到异常出现了。它为什么会出现异常呢？

JVM的默认处理方案
- 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
- 程序停止执行

我们在来理解一下JVM的默认处理方案
jvm发现运算是已经违反了数学运算规则,java将这种常见的问题进行描述,并封装成了对象叫做ArithmeticException
当除0运算发生后,jvm将该问题打包成了一个异常对象.
并将对象抛给调用者main函数,new ArithmeticException(“/by zero”);

main函数收到这个问题时,有两种处理方式:
- 1. 自己将该问题处理,然后继续运行
- 2.自己没有针对的处理方式,只有交给调用main的jvm来处理
jvm有一个默认的异常处理机制,就将该异常进行处理.并将该异常的名称,异常的信息.异常出现的位置打印在了控制台上
同时将程序停止运行

Try…Catch

那么我们自己如何处理异常呢?

异常的处理方案
- try…catch…finally
- throws

**try...catch...finally的处理格式： **

1 try { 
2      可能出现问题的代码;
3  } catch(异常名 变量) {
4       针对问题的处理;
5  } finally { 
6      释放资源;
7  }

变形格式：

1 try { 
2       可能出现问题的代码;
3  } catch(异常名 变量) { 
4       针对问题的处理;
5  }

注意：
try里面的代码越少越好
catch里面必须有内容，哪怕是给出一个简单的提示

多异常处理

上面我们处理了一个简单的异常，如果我们遇到一个复杂的程序需要我们处理多个异常要怎么办呢？下面我们来学习

多异常的处理
- 每一个写一个try…catch（这样有点过于麻烦）
- 写一个try，多个catch

1 try{
2      ... 
3 }catch(异常类名 变量名) { 
4      ... 
5 } catch(异常类名 变量名) { 
6      ... 
7 } 
8 ...

注意事项： 1:能明确的尽量明确，不要用大的来处理。 2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。

Throwable中的方法

1 getMessage()：获取异常信息，返回字符串。
2 toString()：获取异常类名和异常信息，返回字符串。
3 printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
4 printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。

异常声明Throws

有些时候，我们是可以对异常进行处理的，但是又有些时候，我们根本就没有权限去处理某个异常。或者说，我处理不了，我就不处理了。
为了解决出错问题，Java针对这种情况，就提供了另一种处理方案：抛出。

格式：
- throws 异常类名
- 注意：这个格式必须跟在方法的括号后面。

 1 public class ExceptionDemo { 
 2      public static void main(String[] args) { 
 3            System.out.println("今天天气很好");
 4           try { 
 5                method();
 6           } catch (ParseException e) { 
 7                e.printStackTrace();
 8           } 
 9          System.out.println("但是我要在家学习");
10          method2();
11     } 
12 // 编译期异常的抛出，编译不通过，我们就要抛出异常了 
13     public static void method() throws ParseException { 
14          String s = "2016-09-03";
15         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
16        Date d = sdf.parse(s);
17        System.out.println(d);
18    }
19   // 运行期异常的抛出
20   public static void method2() throws ArithmeticException { 
21        int a = 10; 
22        int b = 0;
23        System.out.println(a / b);
24    }
25 }

注意：

编译期异常抛出，将来调用者必须处理。
运行期异常抛出，将来调用可以不用处理。

throw

上面讲了throws，那么throw又是什么鬼，怎么用，他们有什么区别呢，让我们带着疑问出发

概念：
throw:在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。如果出现了异常情况，我们可以把该异常抛出，这个时候的抛出的应该是异常的对象。
throws和throw的区别
- throws
  - 用在方法声明后面，跟的是异常类名
  - 可以跟多个异常类名，用逗号隔开
  - 表示抛出异常，由该方法的调用者来处理
  - throws表示出现异常的一种可能性，并不一定会发生这些异常
- throw
  - 用在方法体内，跟的是异常对象名
  - 只能抛出一个异常对象名
  - 表示抛出异常，由方法体内的语句处理
  - throw则是抛出了异常，执行throw则一定抛出了某种异常

学了这么多异常的处理，那么我们到底该如何处理异常呢？我们来总结一下

原则:如果该功能内部可以将问题处理,用try,如果处理不了,交由调用者处理,这是用throws
区别:
- 后续程序需要继续运行就try
- 后续程序不需要继续运行就throws

finally

finally的特点
- 被finally控制的语句体一定会执行
- 特殊情况：在执行到finally之前jvm退出了(比如System.exit(0))
finally的作用
- 用于释放资源，在IO流操作和数据库操作中会见到（我们后面学习中会看到）

finally的用法很简单，这里就不举例了，我们看一个关于finally典型的题

final,finally和finalize的区别?

 1 final
 2     最终的意思，可以修饰类，成员变量，成员方法
 3     修饰类，类不能被继承
 4     修饰变量，变量是常量
 5     修饰方法，方法不能被重写
 6 finally
 7     是异常处理的一部分，用于释放资源。
 8     一般来说，代码肯定会执行，特殊情况：在执行到finally之前jvm退出了
 9 finalize
10     是Object类的一个方法，用于垃圾回收

自定义异常

java不可能对所有的情况都考虑到，所以，在实际的开发中，我们可能需要自己定义异常。而我们自己随意的写一个类，是不能作为异常类来看的，要想你的类是一个异常类，就必须继承自Exception或者RuntimeException

/* * 自定义异常测试类 */
public class StudentDemo { 
      public static void main(String[] args) { 
           Scanner sc = new Scanner(System.in);     
           System.out.println("请输入学生成绩："); 
            int score = sc.nextInt(); 
            Teacher t = new Teacher(); 
             try { 
                   t.check(score); 
             }  catch (MyException e) { 
                   e.printStackTrace(); 
             } 
        }
}
/* *自定义 */
class MyException extends Exception { 
           public MyException() { } 
           public MyException(String message) {
                  super(message);
           }
}
//老师类
 class Teacher { 
          public void check(int score) throws MyException { 
               if (score > 100 || score < 0) {
                   throw new MyException("分数必须在0-100之间"); 
               } else { 
                   System.out.println("分数没有问题"); 
          }
 }

异常注意事项
我们来学习最后一个知识点

子类重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类。
如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws

作者：清风沐沐
链接：https://www.jianshu.com/p/66ca87a6d9a1
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

Java中关于异常的笔记__转载于简书

原文：https://www.cnblogs.com/hmy-666/p/12336790.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)