java中的异常

最新推荐文章于 2022-08-23 20:26:32 发布

weixin_30609331

最新推荐文章于 2022-08-23 20:26:32 发布

阅读量82

点赞数

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/wq-9/p/10295402.html

异常的概念：

异常（Exception 也称意外）就是在程序的运行中所发生的不正常的事件，他会中断正在运行的程序。

所需文件找不到
网络连接不通或者中断
算术运算出错(被零除)
数组下标越界
装载一个不存在的类或者对null对象的操作
类型的转换异常

异常的处理方式：

捕获异常使用的关键字try、catch、finally

try-catch组合

2.try-finally组合

finally是无论是否产生异常，都执行的代码，但是有一种情况finally不执行，即退出Java虚拟机。

3.try-catch-finally组合

正常情况：执行try-finally
异常情况：类型匹配，执行try-catch-finally

异常不匹配，执行try-finally

如果在catch中存在return语句，则先执行完finally语句再回头执行return语句。

 1 import java.util.Scanner;
 2 
 3 
 4 public class TestTryCatch {
 5 
 6     public static void main(String[] args) {
 7         // TODO Auto-generated method stub
 8 Scanner scanner = new Scanner(System.in);
 9 try{
10     System.out.println("请输入被除数");
11     int numA=scanner.nextInt();
12     System.out.println("请输入除数");
13     int numB=scanner.nextInt();
14     int result=numA/numB;
15     System.out.println(numA+"/"+numB+"="+result);
16     //退出java虚拟机
17     System.exit(0);
18 }catch(ArithmeticException e){
19     System.err.println("除数不能为零");
20     System.out.println("获取异常的字符串的描述"+e.getMessage());
21     return ;
22     //e.printStackTrace();//打印堆栈信息
23 }finally{
24     System.out.println("finally中的代码块执行了");
25 }
26     }
27 
28 }

声明异常关键字throws

方法名的后面，用于声明方法可能会产生一个异常如果方法声明的是Exception类的异常或者是CheckedException异常。要求方法的调用处必须做处理。

继续使用throws向上(方法的调用处)声明
使用try-catch-finally进行处理

如果方法声明的是RuntimeException类型的异常，那么方法的调用处可处理可不处理。

 1 public class TestThrows {
 2 
 3     public static void show()throws Exception{}
 4     public static void method()throws RuntimeException{}
 5     public static void main(String[] args) {
 6         // TODO Auto-generated method stub
 7             try {
 8                 show();
 9             } catch (Exception e) {
10                 // TODO Auto-generated catch block
11                 e.printStackTrace();
12             }
13             method();
14     }
15 
16 }

继承关系中的声明异常

父类的方法声明了Exception类的异常，子类在重写方法时，可以声明也可以不声明。但是如果子类重写后的方法使用supper关键字调用父类的方法，那么要求必须对异常进行处理。
如果父类的方法没有异常，那么子类的方法如果一定会有Exception或者Checked异常，要求子类必须自己使用try-catch处理，或者给父类方法加上异常的声明。
如果子类在重写父类的方法时，产生的异常是RuntimeException异常时，那么可以不用处理。

import java.io.File;
import java.io.IOException;




public class Father {
  public  void show()throws Exception{}
  public void method(){
      
  }
  public void fun(){}
}


class Son extends Father{
public void show(){
    
}
    public void method(){
        File f=new File("D:\\a.txt");
        try {
            f.createNewFile();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void fun()throws RuntimeException {
        super.fun();
    }
    }

throw抛出异常对象

写在方法里

在捕获一个异常前，必须有一段代码先生成异常对象并把它抛出，这个过程我们以手工做，也可以由JRE来实现，但是他们调用的都是throw子句。

 1 public class TestThrow {
 2 public static void show(){
 3     try {
 4         throw new Exception();
 5     } catch (Exception e) {
 6         // TODO Auto-generated catch block
 7         e.printStackTrace();
 8     }
 9 }
10 public static void main(String[] args) {
11     show();
12 }
13 }