Java的异常处理机制知识点【笔记详细】

最新推荐文章于 2023-07-07 06:42:14 发布
最新推荐文章于 2023-07-07 06:42:14 发布
阅读量405 收藏
点赞数
分类专栏： JAVA学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45422321/article/details/106952462
版权

目录标题

1初始异常

1.1什么是异常？

  • 什么是异常，异常机制有什么用？
  • 1.以下程序执行过程中发生了不正常的情况，这种不正常的情况叫做：异常
  • java是很完善的语言，提供了异常的处理方式，以下程序原执行过程总出现了不正常情况
  • java吧该异常信息打印输出到控制台，工程许愿参考。程序员看到异常信息之后，可以对：
  • 程序进行修改，让程序更加健壮
  • 什么是异常：程序执行过程中的不正常情况
  • 异常的作用：增强程序的健壮性
  • 处理异常的第一种方式：
  •  在方法生命的位置上使用throws关键字抛出，谁调用我这个方法，我就抛给谁，抛给调用者来处理

  •  这种异常处理态度：上报
  • 处理异常的第二种方式：
  •  使用try...catch语句对异常进行捕捉

  •  这个异常不会上报，自己就把这个是处理了

  •  异常抛出到此为止，不再上抛了

1.2异常引例

public class Exception01 {

    public static void main(String[] args) {
        int a = 10;
        int b = 0;

        /*if(b==0){
            System.out.println("除数不能为0");
            return;
        }*/
        //程序执行到此处说明除数一定不为0
        int c = a/b;  //实际上JVA在执行到此处的时候，会new异常对象：new ArithmeticException(String s)
        //并且JVM将new的异常对象抛出，打印输出信息到控制台了
        System.out.println(100/0);   //此处也发生了new ArithmeticException(String s) 异常
        System.out.println(a + "/" + b + "=" + c);
    }
}

1.3执行结果

1.3.1结果展示

在这里插入图片描述

1.3.2结果说明

以下程序执行程序出现了：

  • Exception in thread “main” java.lang.ArithmeticException: / by zero
  • at com.power.javase.exception.Exception.main(Exception.java:22)
  • 这个信息被我们称为算术运算异常

2初始异常

2.1异常类创建异常对象

java语言中异常是以什么形式存在的呢？
每一个异常类都可以创建异常对象

2.2代码展示

public class Exception02 {
    public static void main(String[] args){
        //通过"异常类"实例化“异常对象”
        NumberFormatException nfe= new NumberFormatException("数字格式化异常！");
        System.out.println(nfe.toString());

        //通过"异常类"实例化“异常对象”
        NullPointerException npe = new NullPointerException("空指针异常");
        System.out.println(npe.toString());

    }
}

2.3执行结果

在这里插入图片描述

3运行时异常编写程序时可以不处理

3.1代码展示

注意： System.out.println(100/0);中100/0是运行时异常，可以不进行处理

package com.power.javase.exception;

/**
 * java 的异常处理机制
 *
 */

public class ExceptionTest03 {
    public static void main(String[] args) {
        /**
         *
         * 程序执行到此处发生了ArithmeticException异常，
         * 底层new了一个ArithmeticException异常对象，
         * 然后抛出了，由于是main方法调用了100/0，
         * 所以这个异常ArithmeticException抛给了main方法
         * main方法没有处理，将这个异常自动抛给了JVM，
         * JVM最终终止程序的执行
         *
         * ArithmeticException继承RuntimeException,属于运行时异常
         * 在编写程序阶段不需要对这种异常进行预先的处理
         */
        System.out.println(100/0);
        //这里的HelloWorld没有输出，没有执行
        System.out.println("Hello World");
    }
}

3.2执行结果

显示异常
在这里插入图片描述

4方法声明位置上使用throws【方法一】

  • 处理异常的第一种方式：
    在方法生命的位置上使用throws关键字抛出，谁调用我这个方法，我就抛给谁，抛给调用者来处理
  • 这种异常处理态度：上报

4.1代码展示

package com.power.javase.exception;
/*
以下代码标错的原因是什么？
    因为doSome()声明位置上使了：throws ClassNotFoundException
    而ClassNotFoundException(类没找到异常)是编译时异常。必须编写代码处理，没有处理
    编译器报错。
 */
public class ExceptionTest04 {
    public static void main(String[] args) throws ClassNotFoundException {
        /**
         * main()方法中调用doSome()方法
         * //因为doSome()方法声明位置上有：ClassNotFoundException
         * 我们在调用doSome()方法的时候必须对这种异常进行预先的处理
         * 如果我们不处理，编译器就会报错
         * 报错信息:
         * Error:(17, 15) java: 未报告的异常错误java.lang.ClassNotFoundException; 必须对其进行捕获或声明以便抛出
         */
        doSome();

    }
    /**
     * doSome方法在方法声明的位置上是用来：throws
     * 这个代码表示doSome()方法在执行过程中，有可能会出现ClassNotFoundException异常
     * 叫做类没找到异常，这个异常直接父类是：Exception,所以ClassNotFoundException属于编译时异常
     */
    public static void doSome() throws ClassNotFoundException{
        System.out.println("doSome!!!");
    }
}

4.2执行结果

成功调用
在这里插入图片描述

5try…catch捕捉异常【方法二】

使用try…catch语句对异常进行捕捉
这个异常不会上报，自己就把这个是处理了

5.1代码展示

package com.power.javase.exception;

public class ExceptionTest05 {
        //第一种处理凡是：在方法生命的位置上继续使用throws来完成异常的继续上抛，抛给调用者
    /*
        public static void main(String[] args) {
            doSome();
        }
    */
    //第二种处理方式:try ....catch 进行捕捉
    public static void main(String[] args) {
        try{
            doSome();
        }catch (ClassNotFoundException e){
            e.printStackTrace();

        }
    }
        public static void doSome() throws ClassNotFoundException{
            System.out.println("doSome!!!");
        }
    }

5.2执行结果

成功调用
在这里插入图片描述

6异常处理的原理

注意：只要异常没有捕捉，采用上报的发放时，此方法的

  • 希望调用者来处理，选择throws上报
  • 自己捕捉使用try…catch，不上报

6.1代码展示

package com.power.javase.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;


public class ExceptionTest06 {
    //一般不建议在main方法上使用throws,因为这个异常如果真的发生了，一定会传给JVM。JVM只有终止。
    //异常处理机制的作用就是增强程序的健壮性
    public static void main(String[] args) {
        System.out.println("main begin");
        try{
            //try尝试
            m1();
        }catch(FileNotFoundException e){
            //catch是捕捉异常之后走的分支
            System.out.println("文件不存在，可能路径错误，也可能是该文件被删除了！");
        }

        System.out.println("main over");
    }

    public static void m1()throws FileNotFoundException {
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }
    public static void m2()throws FileNotFoundException{
        System.out.println("m2 begin");
        //编译器报错原因是：m3()方法声明位置上有：throws FileNotFoundException
        //我们在这里调用m3()没有对异常尽心能够与处理，所以编译报错
        m3();
        System.out.println("m2 over");
    }
    public static void m3() throws FileNotFoundException {
        //创建一个输入流对象，该流指向一个文件
        /*
        编译时报错的原因是什么？
        第一:这个调用了一个构造方法：FileInputStream(String name)
        第二：这个构造方法的声明位置上有throws FileNotFoundException
        第三：通过类的继承结构看到：FileNotException父类是IOException,IOException的父类是Exception
        最终得知：FileNotFoundException是编译时异常
         */
        //new FileInputStream("D:\\a.txt");

        //我们采用第一种方式：在方法声明的位置上使用throws继续上抛
        //一个方法体当中的代码出现异常之后，如果上报的话，此方法结束。
        new FileInputStream("D:\\a.1txt");
    }
}

6.2执行结果

在这里插入图片描述

7深入try…catch

深入try…catch
1.catch后面的小括号中的类型可以是具体的异常类型，也可使该异常类型的父类型
2.catch 可以写多个。见一些catch的时候，精确的一个一个处理，这样有利于程序的调试
3.catch写多个的时候，从上到下必须遵守从小到大

7.1代码展示

public class ExceptionTest07 {
    private static Object ArithmeticException;

    public static void main(String[] args) {
        /*try{
            FileInputStream fis = new FileInputStream("D:\\a.1txt");
        }
        catch(IOException e){  //多态：IOExceptFileNotFoundExceptionion e = new  e
            System.out.println("文件不存在！");
        }*/

        /*try{
            FileInputStream fis = new FileInputStream("D:\\a.1txt");
            fis.read();
        }
        catch(FileNotFoundException e){  //多态：IOException e = new FileNotFoundException e
            System.out.println("文件不存在！");
        }
        catch(IOException e){
            System.out.println("读文件错了");
        }*/

        System.out.println("hellw world");


        //编译报错
        /*
        try{

            FileInputStream fis = new FileInputStream("D:\\a.1txt");
            fis.read();
            }
        catch(IOException e){
            System.out.println("读文件错了");
        }
        catch(FileNotFoundException e){  //多态：IOException e = new FileNotFoundException e
            System.out.println("文件不存在！");
        }*/

        //JDK8的新特性
        try {
            //创建输入流
            FileInputStream fis = new FileInputStream("D:\\a.1txt");
            //进行数学运算
            System.out.println(100 / 0);
        } catch (FileNotFoundException | ArithmeticException | NullPointerException e) {
            System.out.println("文件不存在！");
        }
    }
}

7.2执行结果

在这里插入图片描述

8异常对象的两个非常重要的方法

异常对象有两个非常重要的方法：
（1）获取异常简单的描述信息：
String msg = exception.getMessage();
System.out.println(msg);
（2） 打印异常追踪的堆栈信息：
exception.printStackTrace();

8.1代码展示

package com.power.javase.exception;
public class ExceptionTest08 {
    public static void main(String[] args) {
        //这里只是为了测试getMassage()方法和printStackTrace()方法
        //这里只是new了异常对象，但是没有将异常对象抛出。JVM会认为这是一个普通的java对象
        NullPointerException e = new NullPointerException("空指针异常fadil");

        //获取异常简单描述：这个信息实际上就是过偶早方法上面的String参数
        String msg = e.getMessage();
        System.out.println(msg);

        //打印异常堆栈信息
        //java后台采用异常堆栈追踪信息的时候，采用了异步线程的方式打印的。
        e.printStackTrace();
        System.out.println("hello world");
    }
}

8.2执行结果

在这里插入图片描述

9出现异常时，怎样快速调试

/*
异常对象有两个非常重要的方法：
获取异常简单的描述信息：
String msg = exception.getMeggage();
打印异常追踪的堆栈信息：
exception.printStackTrace();
我们以后怎么看异常的追踪信息，我们应该怎么看，可以快速的调试程序呢？
异常信息追踪信息，从上往下以下一行一行的看
但是需要注意的是：SUN写的代码就不用看了
*/

9.1代码展示

package com.power.javase.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;


public class ExceptionTest09 {
    public static void main(String[] args) {
        try{
            m1();
        }catch(FileNotFoundException e){
           //获取简单的描述信息
            String msg = e.getMessage();
            System.out.println(msg); //D:\a.1txt (系统找不到指定的文件。)

            //打印异常堆栈追踪信息
            //在实际开发中，建议使用这个，养成好习惯

          // e.printStackTrace();
           /*
           ava.io.FileNotFoundException: D:\a.1txt (系统找不到指定的文件。)
           at java.io.FileInputStream.open0(Native Method)
            at java.io.FileInputStream.open(FileInputStream.java:195)
            at java.io.FileInputStream.<init>(FileInputStream.java:138)
            at java.io.FileInputStream.<init>(FileInputStream.java:93)
            at com.power.javase.exception.ExceptionTest09.m3(ExceptionTest09.java:30)
            at com.power.javase.exception.ExceptionTest09.m2(ExceptionTest09.java:27)
            at com.power.javase.exception.ExceptionTest09.m1(ExceptionTest09.java:24)
            at com.power.javase.exception.ExceptionTest09.main(ExceptionTest09.java:16)
            30导致27，27导致24，24导致16，

            */
        }
        //这里程序不耽误执行，很健壮（服务器不会因为遇到异常而宕机）
        System.out.println("Hello World!");

    }
    public static void m1() throws FileNotFoundException{
        m2();
    }
    public static void m2() throws FileNotFoundException{
        m3();
    }
    public static void m3() throws FileNotFoundException{
        new FileInputStream("D:\\a.1txt");
    }
}

9.2执行结果

在这里插入图片描述

10读取文件时异常使用方法

关于try…catch中的finally字句：
1.在finally语句中的代码时最后执行的，并且是一定会执行的，即使try语句块中的代码出现了异常
finally字句必须和try一起出现，不能单独编写

2.finally语句通常使用在那些情况下呢？
通常在finally语句块中完成资源的释放/关闭
因为finally中的代码块比较有保障
即使try语句块中的代码出现异常，finally中代码也会正常执行
3.流使用完需要关闭，因为流是占用资源的，即使以上程序出现异常，流也是必须要关闭

10.1代码展示

package com.power.javase.exception;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ExceptionTest10 {
    public static void main(String[] args) {
        FileInputStream fis = null; //声明位置放到try外面，这样在finally中才能用
        try{
            //创建输入流对象
            fis = new FileInputStream("D:\\a.1txt");
            //开始读文件...

            String s = null;
            //这里一定会出现空指针异常
            s.toString();

            //流使用完需要关闭，因为流是占用资源的
            //即使以上程序出现异常，流也是必须要关闭
            //放在这里有可能流关不了

        }catch(FileNotFoundException e){
            /*String stg = e.getMessage();
            System.out.println(stg);*/
            //e.printStackTrace();
            System.out.println(e.getMessage());   //2和3本质区别在于一个需要输出 System.out.println()函数
        }finally{
            System.out.println("Hello haoke");
            //流的关闭放到这里比较保险
            //finally中代码是一定会执行的
            //即使try中出现了异常！
            if(fis != null){    //避免空指针异常
                try{
                    //close()方法有异常，采用捕捉的方式
                    fis.close();
                }catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

10.2执行结果

正确的文件名是D:\a.txt，此处我指定的是错误的文件名（D:\a.1txt）
在这里插入图片描述

11 try-catch- finally执行顺序

    try和finally,没有catch可以吗？可以
        try不能单独使用
        try finally 可以联合使用
    以下代码的执行顺序：
        先执行try......
        再执行finally
        最后执行return  (return执行方法必然结束)

11.1代码展示

package com.power.javase.exception;
/*
finally语句：放在finally里面的代码是一定会执行的
 */
public class ExceptionTest11 {
    public static void main(String[] args) {
        try{
            System.out.println("try.........");
            return;
        }finally{                                   //就算try中有return语句，finally也会执行到
            //finally中的语句会执行，能执行到
            System.out.println("finally...........");
        }

        //这里不能写语句，因为这个代码是无法执行到的
        //System.out.println("hello world");
    }
}

11.2执行结果

在这里插入图片描述

12唯有 System.exit(0)，finally语句不再执行

System.exit(0);只有这种情况下，退出JVM之后，finally语句中的代码不再执行

12.1代码展示

package com.power.javase.exception;
/*
fially
 */
public class ExceptionTest12 {
    public static void main(String[] args) {
        try{
            System.out.println("try...");
            //退出JVM
            System.exit(0);//退出JVM之后，finally语句中的代码就不执行了
        }finally{
            System.out.println("finally...");
        }
    }
}

12.2执行结果

在这里插入图片描述

13Finanlly面试题

13.1代码展示

package com.power.javase.exception;
/*
finally面试题
 */
public class ExceptionTest13 {
    public static void main(String[] args) {
        int result = m();
        System.out.println(result);
    }
    /*
    java语法规则（有一些规则是不能破坏的，一旦这么说来，就必须这么做）
        Java中有一条这样的规则：
            方法体中的代码必须遵循自上而下书匈奴以此逐行执行（恒古不变的语法）
         Java中还有一条语法规则：
            return语句一旦执行，整个方法必须结束（恒古不变的语法）
    */
    public static int m(){
        int i=100;
        try{
            //这行代码出现在int i = 100 的下面，所以最终解雇必须是返回100
            //return 语句还必须保证是最后执行的。一旦执行，整个方法结束
            return i;
        }finally{
            i++;
        }
    }
}

13.2反编译过程

可以看出，此时找了一个临时变量

反编译之后的效果   找了个临时变量
public static int m(){
    int i = 100;
    int j = i;
    i++;
    return j;
}

13.3执行结果

执行结果为100
在这里插入图片描述

14初始异常

fianl finally finalize 有什么区别？
final关键字
final修饰的类无法继承
final 修饰的方法无法覆盖
final 修饰的变量不能重新赋值
finally 关键字
和try联合使用
finally语句块中的代码时必须执行的

finalize 标识符
是一个Object类中的方法名
这个方法是由垃圾回收器GC负责调用的

14.1代码展示

package com.power.javase.exception;
/*
fianl finally finalize 有什么区别？
final关键字
    final修饰的类无法继承
    final 修饰的方法无法覆盖
    final 修饰的变量不能重新赋值
finally 关键字
    和try联合使用
    finally语句块中的代码时必须执行的

finalize 标识符
    是一个Object类中的方法名
    这个方法是由垃圾回收器GC负责调用的
 */
public class ExceptionTest14 {
    public static void main(String[] args) {
        //final是一个关键字，表示最终的，不可变的
        final int i = 100;

        //i = 200;

        //finally也是一个关键字，和try联合使用，使用在异常处理机制中
        //再finally语句块中的代码是一定会执行的
        try{

        }finally{
            System.out.println("finally.....");
        }

        //finalize()是Object类中的一个方法，作为方法名出现
        //所以finalize()是标识符
        Object object;
    }
}
//final 修饰的类无法继承
final class A{
    //常量
    public static final double PI=3.1415926;
}
class B{
    //final修饰的方法无法覆盖
    public final void doSome(){

    }
}

14.2执行结果

在这里插入图片描述

15怎么样自定义异常

15.1自定义异常方法

1、SUN提供的JDK内置的异常肯定是不够用的。在实际开发过程中，有很多业务，
这些业务踹你异常之后，JDK都是没有的。和业务挂钩的。那么异常我们
程序员可以自己编写吗？
可以。
2.Java中怎么自定义异常呢?
两步？
第一步：编写一个类继承Exception或者RuntimeException
第二部：提供两个构造方法，一个无参的，一个带有String参数
死记硬背。

15.2代码展示

以下两个代码块含义一样

public class MyException extends Exception{ //编译时异常
    public MyException(){
    }
    public MyException(String s){
        super(s);
    }
}

package com.power.javase.exception;
栈操作异常：自定义异常
 */
public class MyStackOperationException extends Exception{
    //无参构造
    public MyStackOperationException(){     //编译时异常
    }

    //有参构造
    public MyStackOperationException(String s){
        super(s);
    }
}
学而时习之，不亦说乎？
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java异常处理机制
小贺想改变
10-02 1047
主要介绍Java的处理机制是什么以及两种主要处理机制，try-catch-finally和throws以及一些练习题
Java 异常处理机制（全）
qq_48010634的博客
12-06 6447
Java异常处理与异常体系结构
Java异常的处理机制
最新发布
qq_39939541的博客
07-07 1876
finally块必定会被执行，通常用于释放资源或进行清理工作。除了Java提供的异常类之外，我们还可以自定义异常类来表示特定的异常情况。在Java中，可以通过创建自定义的类来定义自己的异常。自定义异常类通常需要继承自Java提供的异常类（如Exception或RuntimeException）或它们的子类。// 自定义异常类 public class MyException extends Exception {
Java异常处理机制全网最详细总结（小白也能理解）
m0_51358164的博客
03-03 3461
Java异常处理机制全网最详细总结（小白也可以轻松理解）
Java中异常处理的机制是什么？
ljh_23333的博客
04-30 3050
总之，在 Java 中，异常处理是一种重要的机制，用于检测和处理程序执行期间可能出现的错误和异常情况。try 块中包含可能引发异常的代码，catch 块中包含处理异常的代码。在上面的代码中，try 块包含可能引发异常的代码，catch 块包含处理异常的代码。当异常被抛出时，程序会跳转到与其类型匹配的 catch 块，并执行其中的代码。Java的异常处理机制由三个关键部分组成：抛出异常、捕获异常和处理异常。- 抛出新异常：有时，我们可能希望将当前异常转换为不同的异常类型并重新抛出，以便更好地描述问题。
Java 中的异常处理机制
KevinChen2019的博客
10-17 6365
Java的异常处理机制可以让程序具有极好的容错性，让程序更加健壮。当程序运行出现意外情形时，系统会自动生成一个Exception对象来通知程序，从而实现将“业务功能实现代码” 和 “错误处理代码” 分离，提供更好的可读性。
Java的异常处理以及重要的知识点OOM
m0_71395231的博客
07-29 410
Java的异常处理以及重要的知识点OOM
Java 异常相关知识总结
不想掉头发$的博客
08-02 355
目录 前言 异常的概念 异常类体系图 异常体系内容详解 Throwable 常用成员方法 编译时异常和运行时异常的区别 异常处理方法 JVM默认处理异常的方式： try-catch方式： 定义格式： 执行流程: 细节理解 throws方式处理异常 定义格式 注意事项 throws和throw的区别 自定义异常 定义 1.自定义异常的步骤 2.自定义异常类使用案例 前言 在了解异常类相关问题之前，请先思考一下问题，将问题带到下面的内容的阅读中去。 ...
java各知识点详细总结(毕向东笔记整理)
01-30
java各知识点详细总结(毕向东笔记整理)。第一章：编程基础 3-11 第二章：数组 11 -31 第三章：面向对象程序开发 31 -74 第四章：异常机制 74 -89 第五章：多线程技术 89 -122122122 第六章：常用类 API 122API 122 ...
JavaSE知识点笔记总结(包~异常处理机制)
11-05
适合初学者的笔记 从java语言的JDK到面向对象中的异常 期间的知识点进行一个汇总，简单概括了各个知识点的基础语法与原理，利用思维导图的写法，更容易理清每个知识点的思路，适合在知识点较为模糊的时候看一看,巩固...
java-IO流与异常机制学习笔记
03-28
自己总结,知识点全面,包含了,IO流,异常机制等学习笔记 含有代码实例可供参考,需要mybase打开 持续更新,需要的自行下载 附上本人写的学习博客 https://blog.csdn.net/qq_35577787/article/details/105088073
超详细的Java复习知识点2019——个人笔记.zip
06-24
这份名为"超详细的Java复习知识点2019——个人笔记"的文档，旨在为初学者提供一个全面且深入理解Java基础知识的指南。笔记内容可能涵盖了以下几个关键领域： 1. **Java语法基础**：包括变量、数据类型、运算符、...
java笔记整理(超详细) java笔记整理(超详细)
07-14
以下是关于Java的一些核心知识点： 1. **面向对象特性**： - 封装：将数据和操作数据的方法绑定在一起，形成一个独立的实体，减少外部对内部状态的直接访问。 - 继承：子类继承父类的属性和方法，实现代码复用，...
Java中的异常处理机制
zsyoung的博客
10-18 612
java把所有非正常情况分成两种：异常（Exception）和错误（Error），都是继承自Throwable父类。  Error错误：一般是指虚拟机相关的问题，如系统崩溃，虚拟机出错误等，这种错误无法恢复或不可能捕获，将导致应用程序中断，通常不处理。  Exception异常:指不期而至的各种状况，如：文件找不到、网络连接失败、非法参数等。          异常是一个
Java的异常！白学JA的第15天
Helltaker的博客
07-26 283
写在前面： 生活中的异常，有哪些？ 例如：正常情况下，小王每日开车去上班，耗时大约30分钟。 但是小王通常会提早40~45分钟出门，这是为什么？ 因为有“异常”的存在！异常可能是堵车、撞车、汽车故障等各种可能发生的事件，导致上班这一操作无法按时完成。 Java程序中的异常什么是异常什么是异常处理Java中如何进行异常处理try-catch块打印错误信息常见的异常类型try-catch_finally块多重catch声明异常抛出异常自定义异常异常处理原则 什么是异常 异常是指在程序的运行过程中所发生的不正常的
Java的异常处理机制
热门推荐
BoSea
09-22 5万+
一、什么是java异常？ java异常指在程序运行时可能出现的一些错误，如：文件找不到、网络连接失败、非法参数等。异常是一个事件，它发生在程序运行期间，中断了正在执行的程序的正常指令流。Java通过API中Throwable类的众多子类描述各种不同的异常。因而，Java异常都是对象，是Throwable子类的实例，描述了出现在一段编码中的错误条件。当条件生成时，错误将引发异常。 Java异常类...
【Java-----异常处理机制详解】
qq_45071131的博客
10-19 1448
本文主要讲了Java中异常的体系结构以及分类，以及Java中异常的处理机制，以及处理方法。程序运行时，发生的不被期望的事件，它阻止了程序按照程序员的预期正常执行，这就是异常。异常发生时，是任程序自生自灭，立刻退出终止，还是输出错误给用户？Java的解决方法是异常处理机制。异常处理机制能让程序在发生异常时，按照代码的预先设定的异常处理逻辑，针对性的处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。 Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw语句手动抛出的，
Java异常知识点
qq_53881918的博客
08-08 282
Java 异常概念Java程序在执行过程中所发生的异常(运行时一切不正常情况)事件可分 为两类：1.ErrorJava虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。一般不编写针对性的代码进行处理。其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如： 访问数组下标越界 试图读取不存在的文件 网络连接中断。...
JAVA中case的简单用法
weixin_45422321的博客
05-28 7931
public class Switchtest { public static void main(String[] args) { java.util.Scanner s = new java.util.Scanner(System.in); System.out.println("Welcome to come here! "); System.out.print("please input the first number:"); int num1 = s.nex.
JAVA就业班第一阶段学习笔记：异常处理与数据库访问
在学习JAVA的过程中，第一阶段的笔记涵盖了JavaSE、MySQL以及如何在Java程序中处理异常，这些都是基础且重要的知识点。以下是对这些内容的详细解析： 首先，JavaSE部分涉及到给代码添加注释，这对于理解和维护代码...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值