Java异常处理

最新推荐文章于 2024-01-12 11:08:53 发布
最新推荐文章于 2024-01-12 11:08:53 发布
阅读量718 收藏
点赞数
文章标签： java intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47599156/article/details/124338013
版权

异常处理

1、异常概述

2、Error举例

 public class ErrorTest {
     public static void main(String[] args){
         //1、栈溢出：java.lang.StackOverflowError
         main(args);
 ​
         //2、堆溢出：java.lang.OutOfMemoryError
         Integer[] arr = new Integer[1024*1024*1024];
     }
 }

3、异常的体系结构

注：红色→编译时异常→执行javac.exe命名时，可能出现的异常

蓝色→运行时异常→执行java.exe命名时，出现的异常

异常体系结构：

java.lang.Throwable

|----java.lang.Error:一般不编写针对性的代码进行处理

|----java.lang.Execption:可以进行异常处理

        |------编译时异常(checked)

                |------IOExecption

                        |------FileNotFoundExecption

                |------ClassNotFoundExecption

        |------运行时异常(unchecked，RuntimeException)

                |------NullPointerException

                |------ArrayIndexOutOfBoundsException

                |------ClassCastException

                |------NumberFormatException

                |------InputMismatchException

                |------ArithmaticException

面试题：常见的异常都有哪些？举例说明

常见异常的举例

 package Exception;
 ​
 import org.junit.Test;
 ​
 import java.io.File;
 import java.io.FileInputStream;
 import java.util.Date;
 import java.util.Scanner;
 ​
 public class ExceptionTest {
 ​
     //-------------以下为编译时异常-------------
     @Test
     public void test7(){
         File file = new File("hello.txt");
         FileInputStream fis = new FileInputStream(file);
 ​
         int data = fis.read();
         while(data != -1){
             System.out.print((char)data);
             data = fis.read();
         }
         fis.close();
     }
 ​
     //-------------以下为运行时异常-------------
     //ArithmeticException
     @Test
     public void test6(){
         int a =10;
         int b = 0;
         System.out.println(a/b);
     }
 ​
     //InputMismatchException
     @Test
     public void test5(){
         Scanner scanner = new Scanner(System.in);
         int score = scanner.nextInt();
         System.out.println(score);//输入abc
     }
 ​
     //NumberFormatException
     @Test
     public void test4(){
         String s = "123";
         s = "abc";
         int n = Integer.parseInt(s);
     }
 ​
     //ClassCastException
     @Test
     public void test3(){
         Object o = new Date();
         String str = (String)o;
     }
 ​
     //IndexOutOfBoundsException
     @Test
     public void test2(){
         //ArrayIndexOutOfBoundsException
         int[] a = new int[10];
         System.out.println(a[10]);
         //StringIndexOutOfBoundsException
         String s = "abc";
         System.out.println(s.charAt(3));
     }
 ​
     //NullPointerException
     @Test
     public void test1(){
         int a[] = null;
         System.out.println(a[3]);
 ​
         String s = "abc";
         s = null;
         System.out.println(s.charAt(0));
     }
 }

4、异常处理方式背景

4.1 背景

 

4.2 异常处理方式

异常的处理：抓抛模型

  • 过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。一旦抛出对象后，此后的代码就不再执行。

    关于异常对象的产生：①系统自动生成的异常对象

                                        ②手动的生成一个异常对象，并抛出（throw）

  • 过程二：“抓”：可以理解为异常的处理方式：①try-catch-finally ②throws

5、方式一：try-catch-finally

5.1 基本格式

try{

//可能出现异常的代码

}catch(异常类型1 变量名1){

//处理异常的方式1

}catch(异常类型2 变量名2){

//处理异常的方式2

}catch(异常类型3 变量名3){

//处理异常的方式3

}

......

finally{

//一定会执行的代码

}

5.2 说明

  1. finally是可选的

  2. 使用try将可能出现异常的代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配

  3. 一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况下）继续执行其后的代码。

  4. catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓；

    catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面，否则报错。

  5. 常用的异常对象处理的方式：

    • String getMessage( )

    • printstacktrace( )

  6. 在try结构中声明的变量，在出了try结构以后，就不能再被调用了

  7. try-catch-finally结构可以嵌套

体会1：使用try-catch-finally处理编译时异常，使得程序在编译时就不再报错，但是运行时仍可能报错。相当于我们使用try-catch-finally将一个编译时可能出现的异常，延迟到运行时出现。

体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-  finally了，针对编译时异常，我们一定要考虑异常处理。

实例：

 
package Exception;
 ​
 import org.junit.Test;
 ​
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 ​
 public class ExceptionTest1 {
 ​
     @Test
     public void test1(){
         String s = "123";
         s = "abc";
         int n = 0;
         try{
             n = Integer.parseInt(s);
             System.out.println("hello1");
         }catch(NullPointerException e){
             System.out.println("出现空指针异常了，不要着急哦~");
         }catch(NumberFormatException e){
             System.out.println("出现数值转换异常了，不要着急哦~");
             System.out.println(e.getMessage());
             e.printStackTrace();
         }catch(Exception e){
             System.out.println("出现异常了，不要着急哦~");
         }
         System.out.println(n);
         System.out.println("hello2");
     }
 ​
     @Test
     public void test2(){
         try{
             File file = new File("hello.txt");
             FileInputStream fis = new FileInputStream(file);
 ​
             int data = fis.read();
             while(data != -1){
                 System.out.print((char)data);
                 data = fis.read();
             }
             fis.close();
         }catch(FileNotFoundException e){
             e.printStackTrace();
         }catch(IOException e){
             e.printStackTrace();
         }
 ​
     }
 ​
 }

5.3 finally使用说明

  1. finally是可选的

  2. finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。

  3. 像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动回收的，我们需要自己手动的进行资源的释放。此时的资源释放，就需要声明在finally中。

实例：

 package Exception;
 ​
 import org.junit.Test;
 ​
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.IOException;
 ​
 public class FinallyTest {
 ​
     @Test
     public void test2() {
         FileInputStream fis = null;
         try {
             File file = new File("hello.txt");
             fis = new FileInputStream(file);
 ​
             int data = fis.read();
             while (data != -1) {
                 System.out.print((char) data);
                 data = fis.read();
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 if(fis != null)
                     fis.close();
             }catch(IOException e){
                 e.printStackTrace();
             }
         }
     }
 ​
     @Test
     public void testMethod(){
         int num = method();
         System.out.println(num);
     }
 ​
     public int method(){
         try{
             int[] a = new int[10];
             System.out.println(a[10]);
             return 1;
         }catch(ArrayIndexOutOfBoundsException e){
             e.printStackTrace();
             return 2;
         }finally{
             System.out.println("我一定会被执行");
             return 3;
         }
     }
 ​
     @Test
     public void test1(){
         try{
             int a = 10;
             int b = 0;
             System.out.println(a / b);
         }catch(ArithmeticException e){
 //            e.printStackTrace();
             int[] a = new int[10];
             System.out.println(a[10]);
         }
 //        System.out.println("我怎么能这么帅呢！");
         finally{
             System.out.println("我是真滴帅啊~");
         }
     }
 ​
 }

6、方式二：throws

66.1 使用说明

  1. “throws + 异常类型”写在方法声明处。指明此方法执行时，可能会抛出的异常类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象。此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行了 。

  2. 体会：try-catch-finally:真正的将异常给处理掉了。

    throws的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。

6.2 重写方法的异常抛出

说明：子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型

实例：

 package Exception;
 ​
 import java.io.FileNotFoundException;
 import java.io.IOException;
 ​
 public class OverrideTest {
 ​
     public static void main(String[] args){
         OverrideTest test = new OverrideTest();
         test.display(new SubClass());
     }
 ​
     public void display(SuperClass s){
         try{
             s.method();
         }catch(IOException e){
             e.printStackTrace();
         }
     }
 }
 ​
 class SuperClass{
 ​
     public void method() throws IOException {
 ​
     }
 }
 ​
 class SubClass extends SuperClass{
 ​
     public void method() throws FileNotFoundException {
 ​
     }
 }

7、开发中如何选择使用 try-catch-finally 还是使用 throws ?

  • 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws；意味着如果子类重写的方法中有异常，则必须使用try-catch-finally方式处理。

  • 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进的关系执行的。我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。

8、手动抛出异常

实例：

 package Exception;
 ​
 public class StudentTest {
     public static void main(String[] args){
         try{
             Student s = new Student();
             s.register(-109);
             System.out.println(s);
         }catch(Exception e){
             System.out.println(e.getMessage());
         }
     }
 }
 ​
 class Student{
 ​
     private int id;
 ​
     public void register(int id) throws Exception{
         if(id > 0){
             this.id = id;
         }else{
 //            System.out.println("您输入的数非法啦！");
             throw new Exception("您输入的数非法啦！");
         }
     }
 ​
     @Override
     public String toString() {
         return "Student{" +
                 "id=" + id +
                 '}';
     }
 }

9、自定义异常

如何自定义异常类：

  1. 继承于现有的异常结构：RuntimeException / Exception

  2. 提供全局常量serialVersionUID

  3. 提供重载的构造器

实例：

 
package Exception;
 ​
 public class MyException extends RuntimeException{
 ​
     static final long serialVersionUID = -7034897193526766939L;
 ​
     public MyException(){
 ​
     }
 ​
     public MyException(String msg){
         super(msg);
     }
 }

10、综合练习

题目：

 

代码：

 
package Exception.Test;
 ​
 public class EcmDef {
 ​
     public static void main(String[] args){
         try{
             int i = Integer.parseInt(args[0]);
             int j = Integer.parseInt(args[1]);
 ​
             int result = ecm(i,j);
 ​
             System.out.println(result);
         }catch(NumberFormatException e){
             System.out.println("数据类型不一致");
         }catch(ArrayIndexOutOfBoundsException e){
             System.out.println("缺少命令行参数");
         }catch(ArithmeticException e){
             System.out.println("除0");
         }catch(EcDef e){
             System.out.println(e.getMessage());
         }
     }
 ​
     public static int ecm(int i,int j) throws EcDef{
         if(i < 0 || j < 0){
             throw new EcDef("分子或分母为负数啦！");
         }
         return i/j;
     }
 ​
 }
 
package Exception.Test;
 ​
 public class EcDef extends Exception{
 ​
     static final long serialVersionUID = -3387516993124228L;
 ​
     public EcDef(){
 ​
     }
 ​
     public EcDef(String msg){
         super(msg);
     }
 ​
 }

11、总结

 

 

飘落的枫叶像思念
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Day21 Java IO流 异常
m0_64350718的博客
02-16 503
异常 Java程序出现不正常的情况 异常的分类 Java中的异常：Throwable 严重的问题：Error，我们不处理，这样的问题一般都是很严重的，比如说内存溢出（OOM） 问题：Exception（异常）分为编译时期异常与运行时期异常 编译时期异常：除了RuntimeException都是编译时期异常，必须要处理，如果不处理，程序编译无法通过，无法运行 运行时期异常：RuntimeException，这样的问题，一般情况下，我们不会对问题本身进行处理，因为这样的问题是在自己写代码的过程中由
FileNotFoundException：File name too long
程裕强的专栏
06-25 6845
java.io.FileNotFoundException: /data/all/XXXXXXXX.pdf (File name too long) at java.io.FileOutputStream.open0(Native Method) at java.io.FileOutputStream.open(FileOutputStream.java:270) at j...
Java语言如何进行异常处理
weixin_44567705的博客
06-18 1914
关键字：throws，throw，try，catch，finally分别代表什么意义？ 在try块中可以抛出异常吗？ Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其他子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Jav...
第七章 异常处理
奕吉啊的博客
02-02 133
异常概述 异常体系结构 java.lang.Throwable |-----java.lang.Error:一般不编写针对性的代码进行处理。 |-----java.lang.Exception:可以进行异常的处理 |------编译时异常(che...
java 异常处理流程_JAVA异常处理流程理解
weixin_35411480的博客
02-12 505
异常处理是JAVA的一大特色，当虚拟机执行代码出现异常的时候，会抛出相应的异常信息。理解虚拟机异常机制能够让我们可以更好的处理异常，不至于导致系统停止运行并可以呈现出友好的异常提示，还可以自己编写异常类来处理相应的错误。1.异常分类由上图所示，异常的基类为Throwable,Error、Exception为其子类。其中，Error经常用来用于表示系统错误或低层资源的错误,不是JAVA层面上能够处理...
java异常处理方式
Accelerator
02-17 142
异常的处理：抓抛模型 过程一：“抛”：程序在正常执行的过程中一旦出现异常，就会在异常代码处，生成一个对应异常类的对象，并将此对象抛出。 一旦抛出对象后，其后的代码就不再执行 过程二：“抓”：可以理解为异常的处理方式： 方式一：try-catch-finally的使用 try{ //可能出现异常的代码 }catch（异常类型1 变量名1）{ //处理异常的方式 catch（异常类型2 变量名2）{ //处理异常的方式 catch（异常类型3 变量名3）{ //处理异常的方式 } ..
java异常处理的简单练习
09-02
Java异常处理是编程中至关重要的一个环节，它用于在程序执行过程中处理错误和不寻常的情况。在Java中，异常处理通过使用try-catch-finally语句块和异常类来进行。以下是对给定代码的详细解释： 1. **异常类的继承**...
java异常处理
06-08
Java异常处理是编程中至关重要的一个环节，它允许程序员优雅地处理程序运行过程中可能出现的错误情况，确保程序的稳定性和健壮性。异常处理机制在Java中被设计为一种结构化的方法，使得程序在遇到不可预见的问题时，...
Java异常处理学习心得
08-28
Java 异常处理学习心得 Java 异常处理是 Java 编程语言中的一个重要概念，它允许开发者捕获和处理程序中的异常，从而确保程序的可靠性和稳定性。在 Java 中，异常处理机制可以分为两种：可控式异常和运行时异常。 ...
Java异常处理实例分析
09-03
Java异常处理是编程中至关重要的一个环节，它帮助开发者优雅地处理程序运行时可能出现的问题，保证程序的稳定性和健壮性。在Java中，异常处理通过`try-catch-finally`结构来实现，同时还可以使用`throw`关键字来声明...
java异常处理机制的理解
weixin_33922672的博客
08-29 495
参考《第一行代码java》《java程序设计教程》java中程序的错误有语法错误、语义错误。如果是语法性错误，在编译时就可以检查出来并解决。语义错误是在程序运行时出现的，在编译时没有错误，但在运行时可能会出现错误导致程序退出，这些错误称为异常。在没有异常处理的情况下，也即默认情况下，程序出现异常后会打印异常信息，同时终止执行异常之后的代码...
关于Java中是否需要进行异常处理！？
starsky1984的专栏
08-10 171
在C#中我看过一个文章说尽量不要使用try catch 去捕获异常，说这样会很浪费系统的资源。我的疑问在Java中使用这样的捕获会浪费很多的资源吗？！
java io的异常_Java 异常与IO流
weixin_33396922的博客
02-12 2534
一、异常想想一下代码会发生什么？public static voidmain(String[] args) {int a = 10;int b = 0;System.out.println(a/b);System.out.println("程序结束");}我们都知道，当分母不能为0，所以程序会报错，这是非编译错误。1、异常的概念：程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执...
java异常处理的实例_Java异常处理实例讲解
weixin_30145703的博客
02-16 810
在Java这种纯面向对象编程语言中，有着“一切皆对象”的说法。所以，java也是通过类来描述程序出现的异常现象。在编译的时候，一些严重的错误，比如说语法错误，会被虚拟机检测出来。而异常指的是程序运行过程中，受到了一些阻碍，无法继续进行下去。这个时候就会抛出异常，从当前位置向上级一层一层地抛出。1、先看一个简单例子：package myException;public class Demo_1 {p...
Java的IO---异常1.0
hujieliang123的博客
12-24 2445
Java的IO---异常1.0
java的IO异常处理
wanshanziji的专栏
01-05 713
java中的 常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。 下面通过FileReader和FileWriter实现文件的复制功能，并实现处理运行中出现的异常。。 import java.io.FileReader
java io的异常_java IO流： IO异常的处理
weixin_39612058的博客
02-20 135
IO异常的处理JDK7之前处理使用try...catch...finally 代码块，处理异常部分try{可能会产出异常的代码}catch(异常类变量 变量名){异常的处理逻辑}finally{一定会执行的代码资源释放}public static void main(String[] args) {// 声明变量FileWriter fw = null;try {//创建流对象fw = new F...
Java异常处理详解与实例
最新发布
xuegvs的博客
01-12 518
编译时异常通常是在编译阶段检测到的错误，而运行时异常则是在程序执行过程中发生的，通常与逻辑错误相关。Java的异常类都是从 `Throwable` 类继承而来的。在上面的例子中，我们抛出了一个自定义异常 `CustomValidationException`，并在 `catch` 块中捕获并处理它。在Java中，我们使用 `try`、`catch` 和 `finally` 关键字来实现异常处理。- 谨慎使用 `finally`：确保 `finally` 块只包含必要的代码，避免引入新的异常。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值