Java异常处理机制

最新推荐文章于 2023-04-30 18:49:44 发布
最新推荐文章于 2023-04-30 18:49:44 发布
阅读量470 收藏 2
点赞数
分类专栏： java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fanfangyu/article/details/126926204
版权

异常概念与简单使用

异常是阻止当前方法或作用域继续执行的问题，在程序中导致程序中断运行的一些指令。
1.什么是异常
在这里插入图片描述
2.try与catch关键字
在程序中出现异常，就必须进行处理

import org.testng.annotations.Test;

//public class testetre {
//    @Test
//    public void dfds(){
//        System.out.println("哈哈哈");
//    }
//}

/**
 异常处理
 1.Throwable是异常的基类，分为Error和Exception，在编程中我们关注Exception
 2.Exception分为编译器异常（受检）和运行期异常（非受检）
 3.异常会导致程序中断无法继续执行，
 4.在开发中，我们需要把可能出现异常的代码使用try语句块包裹起来
 5.处理异常，可以让程序保持运行状态
 6.catch可以有多个，顺序为从子类到父类
 */
public class testetre{
    public static void main(String[] args){
        /**
         * 除法运算
         */
        div(10,0);
    }
    private static void div(int num1,int num2){
        int[] arr ={1,2,3,4,5};
        try {
            System.out.println(arr[5]);
//            int result = num1/num2;
//            System.out.println("result="+result);
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组下标越界");
        }catch (Exception e){
            System.out.println("出错啦");
        }
        System.out.println("程序结束");
        }
}

try_catch_finally的使用

3.异常处理过程分析

  1. 一旦发生异常，则系统会自动产生一个异常类的实例化对象
  2. 此时如果存在了try语句，则会自动找到匹配的catch语句执行，如果没有异常处理，则程序将退出，并由系统报告错误
  3. 所有的catch根据方法的参数匹配异常类的实例化对象，如果匹配成功，则表示由此catch进行处理
    4.finally关键字
    在进行异常的处理之后，在异常的处理格式中还有一个finally语句，那么此语句将作为异常的统一出口，不管是否产生了异常，最终都要执行此段代码
import org.testng.annotations.Test;

//public class testetre {
//    @Test
//    public void dfds(){
//        System.out.println("哈哈哈");
//    }
//}

/**
 异常处理
 1.Throwable是异常的基类，分为Error和Exception，在编程中我们关注Exception
 2.Exception分为编译器异常（受检）和运行期异常（非受检）
 3.异常会导致程序中断无法继续执行，
 4.在开发中，我们需要把可能出现异常的代码使用try语句块包裹起来
 5.处理异常，可以让程序保持运行状态
 6.catch可以有多个，顺序为从子类到父类
 */
public class testetre{
    public static void main(String[] args){
        /**
         * 除法运算
         */
//        div(10,0);
        method();
    }
    private static void div(int num1,int num2){
        int[] arr ={1,2,3,4,5};
        try {
            System.out.println(arr[5]);
//            int result = num1/num2;
//            System.out.println("result="+result);
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组下标越界");
        }catch (Exception e){
            System.out.println("出错啦");
        }finally {
            System.out.println("程序执行完毕");
        }
        System.out.println("程序结束");
        }
    private static int method(){
        int a = 10;
        int b = 5;
        try {
            System.out.println("a="+a);
            System.out.println("b="+b);
            int c = a/b;
            System.out.println("a/b="+c);
            return c;
        }catch ( Exception e){
            //代码测试时使用
            e.printStackTrace();
        }finally {
            System.out.println("finally,");
        }
        return -1;
    }
}

_throw_throws与异常规则

throws关键字主要在方法的声明上使用，表示方法中不处理异常，而交给调用处处理。实际上对于Java程序来讲，如果没有加入任何的异常处理，默认由JVM进行异常的处理操作。
throw关键字表示在程序中手动抛出一个异常，因为从异常处理机制来看，所有的异常一旦产生之后，实际上抛出的就是一个异常类的实例化对象，那么此对象也可以由throws直接抛出。
异常处理的语法规则

  1. try语句不能单独存在，可以和catch、finally组成try…catch…finally、try…catch、try…finally三种结构，catch语句可以有一个或多个，finally 语句最多一个，try、catch、finally这三个关键字均不能单独使用
  2. try、catch、finally三个代码块中变量的作用域分别独立而不能相互访问
  3. 多个catch块时候，Java虚拟机会匹配其中一个异常类或其子类，就执行这个catch块，而不会再执行别的catch块。
import org.testng.annotations.Test;

import java.util.InputMismatchException;
import java.util.Scanner;

//public class testetre {
//    @Test
//    public void dfds(){
//        System.out.println("哈哈哈");
//    }
//}

/**
 异常处理
 1.Throwable是异常的基类，分为Error和Exception，在编程中我们关注Exception
 2.Exception分为编译器异常（受检）和运行期异常（非受检）
 3.异常会导致程序中断无法继续执行，
 4.在开发中，我们需要把可能出现异常的代码使用try语句块包裹起来
 5.处理异常，可以让程序保持运行状态
 6.catch可以有多个，顺序为从子类到父类
 */
public class testetre{
    public static void main(String[] args){
        /**
         * 除法运算
         */
//        div(10,0);
//        method();
//        try {
//            div(20,0);
//        }catch (Exception e){
//            e.printStackTrace();
//        }
//        System.out.println("over");
        input();
    }
    private static void div(int num1,int num2){
        int[] arr ={1,2,3,4,5};
        try {
            System.out.println(arr[5]);
//            int result = num1/num2;
//            System.out.println("result="+result);
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组下标越界");
        }catch (Exception e){
            System.out.println("出错啦");
        }finally {
            System.out.println("程序执行完毕");
        }
        System.out.println("程序结束");
        }
    private static int method(){
        int a = 10;
        int b = 5;
        try {
            System.out.println("a="+a);
            System.out.println("b="+b);
            int c = a/b;
            System.out.println("a/b="+c);
            return c;
        }catch ( Exception e){
            //代码测试时使用
            e.printStackTrace();
        }finally {
            System.out.println("finally,");
        }
        return -1;
    }
    //自动补全：alt+/
    private static int div2(int a,int b)throws ArithmeticException{
        try {
            int c= a/b;
            return c;
        }catch (ArithmeticException e){
            throw new ArithmeticException("除数不能为0");
        }

    }
    private static void input(){
        //ctrl+shift+o 导包
        Scanner input = new Scanner(System.in);
        try {
            int num = input.nextInt();
            System.out.println(num);
        }catch (InputMismatchException e){
            System.out.println("输入不匹配");
        }

    }
}

自定义异常与assert

在Java中，已经提供了很多的异常类的定义，但是我们在实际项目开发中，可能需要使用一些自己的异常类，那么可以通过集成Exception类或已有的异常类的方式完成一个自定义异常类的操作。
classNotFoundException
DataFormatException
RuntimeException
ArithmeticException
IndexOutOfBoungsException
NullPointerException
ClassCastException

/**
 * 自定义异常通常都是通过继承一个异常类来实现的
 * 1.Throwable
 * 2.Exception
 * 3.RuntimeException
 *
 * 自定义异常的实现是重写父类的构造方法
 * 异常对象本身是没有实际功能，只是一个有意义的标识
 */
public class MyException extends Exception{
    public MyException(){
        super();
    }
    public MyException(String message){
        super(message);
    }
}

示例：排错法
user.java

public class User {
    private String username;
    private String password;
    private int age;
    private String sex;

    public User(String username,String password,int age,String sex) {
        super();
        this.username = username;
        this.password=password;
        this.age=age;
        this.sex=sex;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}

UserService.java

public class UserService {
    public User login(String username,String password)throws MyException{
        if("admin".equals(username)){
            throw new MyException("用户名错误");

        }else if ("12345".equals(password)){
            throw new MyException("密码错误");
        }
        User user = new User("admin","12345",18,"男");
        return user;
    }
}

LoginDemo.java

import java.util.Scanner;

public class LoginDemo {
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String name = input.nextLine();
        System.out.println("请输入密码：");
        String pass = input.nextLine();
        UserService us = new UserService();
        try {
            User user=us.login(name,pass);
            System.out.println("登录成功");
            System.out.println(user);

        } catch (MyException e) {
            e.printStackTrace();
        }
    }
}

受检异常：Exception
定义方法时必须声明所有可能会抛出的Exception:在调用这个方法时，必须捕获它的checked exception，不然就得把它的exception传递下去；exception是从java.lang.Exception类衍生出来的。例如：IOException，SQLException就属于Exception
非受检异常：RuntimeException
在定义方法时不需要声明会抛出runtime exception;在调用这个方法时不需要捕获这个runtime Exception;runtime exception是从java.Lang.RuntimeException或java.lang.Error类衍生出来的。例如：NullPointException,IndexOutOfBoundsException就属于runtimeexception
assert关键字，表示断言
当程序执行到某个固定位置的时候，程序中的某个变量的取值肯定是预期的结果，那么这种操作可以使用断言完成。
断言的操作语法：
assert表达式；

菜鸟教程*…*
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java随笔——单元测试@Test异常处理
MoMing丶的博客
07-19 2452
使用IDEA时无法正常使用@Test注解的解决方法： 方法一： 将导入的junit版本降到4.10，即直接导入junit-4.10。 方法二：将 4.12 版本的 **junit-4.12.jar** 和 **hamcrest-core-1.3.jar** 一起导入。
【TestNG快板说三】TestNG分组、捕获异常、传参
nitibu的专栏
02-14 1088
TestNG测试分组 配置@Test 可以通过@Test给多个测试类的测试用例分组，比如某个测试用例既属于smoke又属于uat，那么就可以配置如下： @Test(groups = {"smoke", "uat"}) public void testDemo1() throws InterruptedException{ System.out.print(&am
在JUnit中处理异常的3种方法。 选择哪一个？
最佳 Java 编程
05-18 1502
在JUnit中，有3种流行的方式来处理测试代码中的异常： 尝试捕捉习语 使用JUnit规则 带注解 我们应该使用哪一个？何时使用？ 尝试捕捉习语 这个习语是最受欢迎的习语之一，因为它已在JUnit 3中使用。 @Test public void throwsExceptionWhenNegativeNumbersAreGiven() { tr...
Java中异常处理的机制是什么？
ljh_23333的博客
04-30 2551
总之，在 Java 中，异常处理是一种重要的机制，用于检测和处理程序执行期间可能出现的错误和异常情况。try 块中包含可能引发异常的代码，catch 块中包含处理异常的代码。在上面的代码中，try 块包含可能引发异常的代码，catch 块包含处理异常的代码。当异常被抛出时，程序会跳转到与其类型匹配的 catch 块，并执行其中的代码。Java的异常处理机制由三个关键部分组成：抛出异常、捕获异常和处理异常。- 抛出新异常：有时，我们可能希望将当前异常转换为不同的异常类型并重新抛出，以便更好地描述问题。
java---你真的认识异常吗？
myi__的博客
11-06 781
一：异常的概念与体系结构 1.1 异常的概念
高效Java异常处理机制
03-04
Java异常处理成为社区中讨论最多的话题之一。一些人认为Java语言中的已检查异常（CheckedExceptions）是一次失败的尝试。本文认为错误并不在于Java模型本身，而在于Java库设计人员没有认识到方法失败的两个基本原因...
java异常处理机制
01-07
java异常处理机制,异常的概念,发生的原因,throwable,捕获异常的简单思维导图
14.java异常处理机制.zip
最新发布
06-15
14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理机制.zip14.java异常处理...
Java异常处理机制全网最详细总结（小白也能理解）
m0_51358164的博客
03-03 2628
Java异常处理机制全网最详细总结（小白也可以轻松理解）
Java 异常处理机制（全）
qq_48010634的博客
12-06 6142
Java异常处理与异常体系结构
【Java-----异常处理机制详解】
qq_45071131的博客
10-19 1414
本文主要讲了Java中异常的体系结构以及分类，以及Java中异常的处理机制，以及处理方法。程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户？Java的解决方法是异常处理机制。异常处理机制能让程序在发生异常时，按照代码的预先设定的异常处理逻辑，针对性的处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。 Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw语句手动抛出的，
异常机制以及自定义异常
weixin_46649583的博客
09-07 1628
异常分类（异常—>Exception） 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。 例如要打开一个不存在的文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。 错误ERROR：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。 异常体系结构 Error Erro
Java 中的异常处理机制
KevinChen2019的博客
10-17 6230
Java的异常处理机制可以让程序具有极好的容错性，让程序更加健壮。当程序运行出现意外情形时，系统会自动生成一个Exception对象来通知程序，从而实现将“业务功能实现代码” 和 “错误处理代码” 分离，提供更好的可读性。
Java中的异常处理机制
流楚丶格念的博客
08-15 3063
异常从发生异常的方法向外传播，首先传给该方法的调用者，再传给上层调用者，以此类推。将关闭资源的代码写在finally块内，可以满足这种需求，即无论是否发生异常，finally块内的代码总会被执行。如果finally块里也使用了return或throw等导致方法终止的语句，finally块已经终止了方法，系统将不会跳回去执行try块、catch块里的任何代码。不管try块中的代码是否出现异常，也不管哪一个catch块被执行，甚至在try块或catch块中执行了return语句，finally块总会被执行。..
最全最详细的Java异常处理机制
热门推荐
波哩个波的博客
01-27 3万+
一、异常概述与异常体系结构 异常概述 在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。 程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常（开发过程中的语法错误和逻辑错误不是异常）。 Java程序在执行过程中所发生的异常事件可分为两类： ...
Java的异常处理机制
quiet_1的博客
05-01 3623
一、什么是java异常？ java中所有错误的超类为：Throwable。其下有两个子类：Error 和 Exception。 Error的子类描述的都是系统错误，比如虚拟机内存溢出。 Exception的子类描述的都是程序，比如空指针，下标越界等。 通常我们程序中处理的异常都是Exception。 Java异常类的层次结构图： Java所有异常类都是Throwable的子类，它包括Java异常处理的两个重要子类：Error和Exception。 Error：Error及其子类用来描述Ja.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值