java中的异常、处理异常的方法、getMessage和printStackTrace方法、finally语句块、自定义异常&手动抛出异常

最新推荐文章于 2022-09-27 19:02:44 发布
最新推荐文章于 2022-09-27 19:02:44 发布
阅读量1.4k 收藏 11
点赞数 4
分类专栏： Java 文章标签： java 异常 finally
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MrWanC/article/details/103206636
版权

java中的异常、处理异常的方法、getMessage和printStackTrace方法、finally语句块、自定义异常&手动抛出异常

1、异常的定义及其作用

package com.company.exception;
/*
* 1、异常是什么？
*   第一、异常模拟的是现实世界中“不正常的”事件
*   第二、java中采用“类”去模拟异常
*   第三、类是可以创建对象的
*       NullPointerException e = 0x1234;
*       e是引用类型，e中保存的内存地址指向堆中的“对象”
*       这个对象一定是NullPointerException类型
*       这个对象就表示真实存在的异常事件
*       NullPointerException是一类异常
*
* 2、异常机制的作用？
*   java语言为我们提供了一种完善的异常处理机制
*   作用是：程序发生异常事件之后，为我们输出详细的信息。
*   程序员通过这个信息，可以对程序进行一些处理，使程序
*   更加健壮
* */
public class ExceptionTest01 {
    public static void main(String[] args) {

        int a = 10;
        int b = 0;
        int c = a / b;  // ArithmeticException e = oxxxxx;

        // 上面的代码出现异常，“没有处理”，下面的代码不会执行，直接退出JVM
        System.out.println("hello world!");
    }
}
/*
* 以上程序编译通过了，但是运行时出现了异常，表示发生了某个异常事件。
* JVM向控制台输出如下的信息：
*   Exception in thread "main" java.lang.ArithmeticException: / by zero
*	    at com.company.exception.ExceptionTest01.main(ExceptionTest01.java:20)
*本质：程序执行过程中发生了算数异常这个事件，JVM为我们创建了一个ArithmeticException类型的对象。
*并且这个对象中包含了详细的异常信息，并且JVM将这个对象中的信息输出到控制台。
* */

在这里插入图片描述

2、处理异常的两种方法：

2.1 第一种方法：声明抛出 throws
package com.company.exception;

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

/*
* 处理异常有两种方法：
*   1、声明抛出
*       throws
*
*   2、捕捉
*       try...catch...
*
* 以下程序演示第一种方式：声明抛出，在方法声明的位置上使用throws关键字向上抛出异常。
* */
public class ExceptionTest02 {

    //public static void main(String[] args) {

        // 创建文件输入流，读取文件
        // 思考：java编译器是如何知道以下的代码执行过程中可能出现异常，java编译器是如何知道这个异常发生的几率比较高呢？
        // 实际上编译器并没有那么智能，这是因为在声明构造方法的时候写了throws FileNotFoundException
        /*
          public FileInputStream(String name) throws FileNotFoundException {
                 this(name != null ? new File(name) : null);
            }

        */
    //    FileInputStream fis = new FileInputStream("c:/ab.txt");  // 文件不存在
    //}

    // 第一种方法：声明抛出
    // 这是编译不会出错
    // ① public static void main(String[] args) throws FileNotFoundException {
    // ② public static void main(String[] args) throws IOException {
    public static void main(String[] args) throws Exception {
        FileInputStream fis = new FileInputStream("c:/ab.txt");
    }

}
/*
* 以上程序编译不通过
* Error:(19, 31) java: 未报告的异常错误java.io.FileNotFoundException; 必须对其进行捕获或声明以便抛出
* */
2.2 深入了解 throws
package com.company.exception;
/*
* 深入throws
* */
import java.io.*;
public class ExceptionTest03 {
    public static void main(String[] args) throws FileNotFoundException{
        //m1();

        // 使用throws处理异常不是真正的处理异常，而是推卸责任
        // 谁调用了就会抛给谁
        // 上面的m1方法如果出现了异常，因为采用的是上抛，给了JVM，JVM遇到这个异常就会退出JVM，下面的代码就不会执行

        // 真正处理：
        try{
            m1();
        }catch(FileNotFoundException e){}

        System.out.println("hello world!");
    }

    public static void m1() throws FileNotFoundException{
        m2();
    }

    public static void m2() throws FileNotFoundException{
        m3();  // 此时这里会出现编译异常，需要加throws，依次类推m1()、main()方法声明均需要加入throws
    }

    public static void m3() throws FileNotFoundException{
        new FileInputStream("c/ab.txt"); // FileInputStream构造方法声明位置上使用throws(向上抛)
    }
}

/*
* // 在程序运行过程中发生了FileNotFoundException类型的异常
* // JVM为我们创建了一个FileNotFoundException类型的对象
* // 该对象中携带以下的信息
* // JVM负责将该对象的信息打印到控制台，并且JVM停掉了程序的运行
* Exception in thread "main" java.io.FileNotFoundException: c\ab.txt (系统找不到指定的路径。)
	at java.base/java.io.FileInputStream.open0(Native Method)
	at java.base/java.io.FileInputStream.open(FileInputStream.java:219)
	at java.base/java.io.FileInputStream.<init>(FileInputStream.java:157)
	at java.base/java.io.FileInputStream.<init>(FileInputStream.java:112)
	at com.company.exception.ExceptionTest03.m3(ExceptionTest03.java:25)
	at com.company.exception.ExceptionTest03.m2(ExceptionTest03.java:21)
	at com.company.exception.ExceptionTest03.m1(ExceptionTest03.java:17)
	at com.company.exception.ExceptionTest03.main(ExceptionTest03.java:8)
* */
2.3 第二种方法： try…catch…
package com.company.exception;

import java.io.*;

/*
* 处理异常的第二种方式：
*   捕捉
*   try...catch...
*
* 语法：
*   try{
*       可能出现异常的代码；
*   }catch(异常类型1 变量){
*       处理异常的代码；
*   }catch(异常类型2 变量){
*       处理异常的代码；
*   }...
*
*   1、catch语句块可以写多个
*   2、但是从上到下catch，必须从小型异常到大型异常进行捕捉。
*   3、虽然小型异常可以去掉，但是为了更加准确的找到异常，最好不要舍掉。
*   4、try...catch...中最多执行1个catch语句块。执行结束之后try...catch...就结束了
* */
public class ExceptionTest04 {
    public static void main(String[] args) {
        // 情况①
        // 以下代码编译无法通过，因为FileNotFoundException没有处理。
        /*
        try{
            // 下面语句是FileNotFoundException异常
            FileInputStream fis = new FileInputStream("c:/ab.txt");
        }catch(ArithmeticException e){ //捕获的代码是算术异常

        }
         */


        // 情况②
        // 以下程序编译通过
        /*
        try{
            // 下面语句是FileNotFoundException异常
            FileInputStream fis = new FileInputStream("c:/ab.txt");
        }catch(FileNotFoundException e){

        }
        */


        // 情况③
        // 以下程序编译无法通过
        // 因为还有更多的IOException没有处理
        /*
        try{
            // 下面语句是FileNotFoundException异常
            FileInputStream fis = new FileInputStream("c:/ab.txt");

            fis.read();  // 因为它抛出的是throws IOException异常

        }catch(FileNotFoundException e){

        }

         */


        // 情况④
        // 以下编译可以通过
        /*
        try{
            // 下面语句是FileNotFoundException异常
            FileInputStream fis = new FileInputStream("c:/ab.txt");

            fis.read();  // 因为它抛出的是throws IOException异常

        }catch(FileNotFoundException e){

        }catch(IOException e){

        }
         */


        // 情况⑤
        /*
        // 这个也是编译通过的，因为IOException包含FileNotFoundException
        try{
            // 下面语句是FileNotFoundException异常
            FileInputStream fis = new FileInputStream("c:/ab.txt");

            fis.read();  // 因为它抛出的是throws IOException异常

        }catch(IOException e){

        }
         */

        // 情况⑥
        // 这个也会报错，因为IOException包含FileNotFoundException，程序自上而下
        // 第二个catch永远不会执行到，因此会报错。
        // 【注】catch可以写多个，但是必须从上到下，从小到大捕捉！！！
        /*
        try{
            // 下面语句是FileNotFoundException异常
            FileInputStream fis = new FileInputStream("c:/ab.txt");

            fis.read();  // 因为它抛出的是throws IOException异常

        }catch(IOException e){

        }catch(FileNotFoundException e){

        }
         */

    }
}
2.4 一个小例子
package com.company.exception;

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

public class ExceptionTest05 {
    // 编译无法通过
    // IOException没有处理
    /*
    public static void main(String[] args) throws FileNotFoundException{
        FileInputStream fis = new FileInputStream("c:/ab.txt");
        fis.read();
    }
     */

    // 通过
    /*
    public static void main(String args[]) throws FileNotFoundException, IOException {
        FileInputStream fis = new FileInputStream("c:/ab.txt");
        fis.read();
    }
     */

    public static void main(String args[]){

        // 程序执行到此处发生了FileNotFoundException类型的异常
        // JVM会自动创建一个FileNotFoundException类型的对象，该对象的内存地址赋值给catch语句中的e变量
        try{
            FileInputStream fis = new FileInputStream("c:/ab.txt");
            //上面的代码出现了异常，try语句块的代码不再继续执行，直接进入catch语句块中执行。
            System.out.println("TTTTTTTTTTT");  // 这句话并没有执行
            fis.read();
        }catch(FileNotFoundException e){  // 内存地址指向堆中的那个对象是“FileNotFoundException类型的”事件
            System.out.println("读取的文件不存在");

            // 说明FileNotFoundExceptiom将Object中toString方法重写了
            System.out.println(e); //java.io.FileNotFoundException: c:\ab.txt (系统找不到指定的文件。)
        }catch(IOException e){
            System.out.println("其他IO异常");
        }

        // 下面代码会执行
        // catch里面程序语句有执行，就默认异常有处理，下面的就可以执行了
        System.out.println("hello world!");

    }
}

3、关于getMessage和printStackTrace方法的应用

package com.company.exception;

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

/*
* 关于getMessage和printStackTrace方法的应用
* */
public class ExceptionTest06 {
    public static void main(String[] args) {
        try{
            FileInputStream fis = new FileInputStream("c:/abc.txt");

            // JVM为我们执行了一下这段代码，这是我们看不到的
            // FileNotFoundException e = new FileNotFoundException("c:/abc.txt");
            // 然后输出异常是调用了e.getMessage();方法
        }catch(FileNotFoundException e){

            // 打印异常堆栈信息
            // 一般情况下都会使用该方式去调试程序
            e.printStackTrace();
            /*
            java.io.FileNotFoundException: c:\abc.txt (系统找不到指定的文件。)
	            at java.base/java.io.FileInputStream.open0(Native Method)
                at java.base/java.io.FileInputStream.open(FileInputStream.java:219)
                at java.base/java.io.FileInputStream.<init>(FileInputStream.java:157)
                at java.base/java.io.FileInputStream.<init>(FileInputStream.java:112)
                at com.company.exception.ExceptionTest06.main(ExceptionTest06.java:12)

             */

            // 上面的方式会常用一点，因为信息比较详细

            String msg = e.getMessage();
            System.out.println(msg);  //c:\abc.txt (系统找不到指定的文件。)
        }

        // 这段代码会执行
        System.out.println("ABC...");
    }
}

4、关于finally语句块

package com.company.exception;

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

/*
* 关于finally语句块
*   1、finally语句块可以直接和try语句块联用。  try....finally...
*   2、try....catch....finally 也可以
*   3、在finally语句中的代码块是一定会执行的
*
* */
public class ExceptionTest07 {
    public static void main(String[] args) throws FileNotFoundException {
        /*
        try{
            System.out.println("ABC");
            return ;
        }finally{
            System.out.println("Test");
        }
         */



        /*
        try{
            FileInputStream fis = new FileInputStream("c:/ab.txt");
            // 下一句代码不会执行
            System.out.println("TTTTT");
        }finally{
            // 异常上抛没有解决，IOException没有处理，仍然会报错
            // 即使这样下面的语句还是执行了
            System.out.println("AAAAAAA");
        }
         */


        // 只有在执行finally语句块之前退出JVM，则finally语句块不会执行
        try{

            // 退出JVM
            System.exit(0);
        }finally{

            // 没有执行
            System.out.println("BBBBB");
        }

    }
}

深入finally语句块的一个小例子

package com.company.exception;
/*
* 深入finally语句块
* */
public class ExceptionTest08 {
    public static void main(String[] args) {

        int i = m1();
        System.out.println(i);  // 10
    }

    public static int m1(){

        int i = 10;
        try{
            return i;
        }finally{
            i++;
            System.out.println("m1()-->" + i);     // m1()-->11
        }


        // 以上代码的执行原理
        /*
        int i = 10;
        try{
            int temp = i;
            return temp;
        }finally{
            i++;
            System.out.println("m1()-->" + i);
        }
        */
    }
}

finally语句块的应用

package com.company.exception;

import java.io.*;

/*
* finally语句是一定会执行的，所以通常在程序中
* 为了保证某资源一定会释放，所以一般在finally语句块中释放资源
* */
public class ExceptionTest09 {
    public static void main(String[] args) {

        //声明一个文件流类型，由于大括号作用域的原因{}
        FileInputStream fis = null;

        try{
            fis = new FileInputStream("ExceptionTest08.java");
        }catch(FileNotFoundException e){
            e.printStackTrace();
        }finally{
            // 为了保证资源一定得到释放
            if(fis == null){
                try{
                    fis.close();  // 文件流关闭也会引起IOException
                }catch(IOException e){
                    e.printStackTrace();
                }

            }
        }

    }
}

5、自定义异常&手动抛出异常

自定义异常&手动抛出异常的一个例子

package com.company.exception;
/*
* 如何手动抛出异常？如何自定义异常？
*
* 自定义有两种方向：
*   1、编译时异常，直接继承Exception
*   2、运行时异常，直接继承RuntimeException
*
* 例子：自定义”无效名字的异常“（名字长度不能小于6），然后动手抛出异常信息。
* */
// 自定义异常
public class IllegalNameException extends Exception{   //编译时异常
//public class IllegalName Exception extends RuntimeException{  //运行时异常

    // 定义异常一般提供两个构造方法
    public IllegalNameException(){}

    public IllegalNameException(String msg){
        super(msg);
    }
}


package com.company.exception;

// 顾客提供相关的业务
public class CustomerService {

    // 对外提供一个注册的方法
    public void register(String name) throws IllegalNameException{

        // 检查名字长度是否小于6位
        if(name.length() < 6){
            // 非法名字异常

            // 创建异常对象
            //IllegalNameException e = new IllegalNameException("用户名长度不能小于6位");

            // 手动抛出异常
            //throw e;

            // 或者一步搞定
            throw new IllegalNameException("用户名长度不能小于6位");

            /*
            【注意】：
             这里有一个重点需要注意：手动抛出的异常在register方法中编译会报错，需要做处理，
             而此处异常处理应该采用 throws 还是 try...catch...？

             try...catch...:是捕获异常，然后对异常进行处理
                  我们手动抛出的异常，如果在此处又我们手动捕获给处理掉，完全就没有意义了。


             所以应该采用 throws 向上抛，然后再在顾客调用register方法的时候对其进行异常检测捕获。
            */
        }

        System.out.println("注册完成");
    }
}

package com.company.exception;
/*
* 模拟注册
* */
public class Test {
    public static void main(String[] args) {
        // 提供用户名
        String username = "jack";

        // 注册
        CustomerService c = new CustomerService();

        // 如果有异常，就获取，然后进行相关操作
        try{

            c.register(username);
        }catch(IllegalNameException e){

            System.out.println(e.getMessage());
        }

        // 如果没有异常，就执行完register()函数，输出“注册成功”
    }
}

6、在方法重写时说到的一点：重写的方法不能比被重写的方法抛出更宽泛异常。具体指的是什么？

package com.company.exception;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
* 重写的方法不能比被重写的方法抛出更宽泛异常
* */
public class ExceptionTest10 {

}

class A{
    public void m1(){}
}

class B extends A{
    // 下面这句会报错，因为重写的方法不能比被重写的方法抛出更多的异常
    // 父类中m1()方法没有抛出异常，而子类中m1()方法却抛出异常

   // public void m1() throws Exception{}
}


class C{
    public void m2() throws FileNotFoundException {}
}

class D extends C{
    // 下面这句会报错，因为FileNotFoundException属于IOException
    // 重写的方法不能比被重写的方法抛出更高等级的异常

    //public void m2() throws IOException{}
}


class E{
    public void m2() throws IOException{}
}

class F extends E{
    // 这个编译就没有任何问题
    public void m2() throws FileNotFoundException {}
}
Lank蓝柯
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
异常详解
devilzcl的博客
07-15 265
异常处理一、异常的基本概念二、异常的分类和处理1、异常的层次结构2、异常的处理3、深入try...catch4、异常对象的常用方法5、finally子句的使用三、如何自定义异常四、方法覆盖与异常 一、异常的基本概念 1:、什么是异常？ A：程序在运行过程中出现的错误。 2、为什么要引入异常处理机制？ 程序执行过程中出现不正常情况，把异常信息打印到输出控制台（异常信息由 JVM 打印），供程序员参考 程序员看到异常信息后，可以对程序进行修改，让程序更加健壮 3、java 语言中异常以什么形式存在？ 异
Java中自定义异常详解及实例代码
08-31
下面将详细介绍Java中自定义异常的概念、创建方法以及如何在实际代码中使用。 1. **自定义异常的概念** 自定义异常是扩展Java内置异常类（通常是`Exception`或其子类）的行为，以创建符合特定业务需求的异常类型。...
JAVA基础——异常详解
weixin_30650039的博客
07-03 216
JAVA异常与异常处理详解 一、异常简介 什么是异常？ 异常就是有异于常态，和正常情况不一样，有错误出错。在java中，阻止当前方法或作用域的情况，称之为异常。 java中异常的体系是怎么样的呢？ 1.Java中的所有不正常类都继承于Throwable类。Throwable主要包括两个大类，一个是Error类，另一个是Exception类； 　　　　 2.其中Error类中包括虚拟...
异常处理详解
Agan__的博客
02-21 652
异常处理详解〇、概述一、异常分类二、异常的声明与抛出1.异常的声明2.异常的抛出三、异常的捕获1. 捕获异常--try-catch2. 捕获多个异常--try-catch-catch-...3. 再次抛出异常4. finally 子句5. try-with-Resources 语句四、创建自定义异常类五、异常使用技巧 〇、概述 在理想世界中，用户输入的数据格式永远都是正确的，选择打开的文件永远都是存在的，代码永远不会出现BUG，在现实世界中却充满了各种非法的数据和各种BUG。 对于异常情况，Java 使用了
Java必知必会：异常机制详解
Leeon的博客
05-01 9911
一、Java异常概述 在Java中，所有的事件都能由类描述，Java中的异常就是由java.lang包下的异常类描述的。1、Throwable（可抛出）：异常类的最终父类，它有两个子类，Error与Exception。 Throwable中常用方法有： getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。 getMeage()：返回异常的消息信息。
Java try catch finally异常处理组合详解
08-19
其工作原理是，在try块中执行可能会抛出异常的语句，然后在catch块中捕获并处理异常。try catch组合的语法结构如下： ```java try { // 可能会抛出异常的语句 } catch (异常类型 e) { // 异常处理语句 } ``` try...
Java中异常打印输出的常见方法总结
08-30
"Java中异常打印输出的常见方法总结" ...Case 1: getMessage()/getLocalizedMessage()、Case 2: printStackTrace()、Case 3: 使用try-catch-finally语句来捕获和处理异常、Case 4: 使用日志记录来记录异常信息等等。
一道关于java异常处理的题目
09-01
本题主要考察了Java异常处理的基础知识，包括基本的异常处理结构、自定义异常的创建和使用，以及如何在实际场景中抛出和捕获异常。理解这些概念对于编写健壮的Java程序至关重要。通过解决此类问题，开发者可以更好地...
Java异常处理 如何跟踪异常的传播路径
08-25
try 块用于包装可能抛出异常的代码，catch 块用于捕获和处理异常，而 finally 块用于执行一些必要的清理工作。在 Java 中，可以使用多个 catch 块来捕获不同的异常类型，并可以使用 finally 块来执行一些必要的清理...
异常的详解
最新发布
m0_53677355的博客
09-27 445
处在方法声明参数列表之后，当方法抛出编译时异常时，用户不想处理该异常，此时就可以借助throws关键字给方法的调用者来处理，即当前方法不处理异常，提醒方法的调用者处理异常。3、方法内部如果抛出了多个异常，throws之后必须跟多个异常类型，之间用逗号隔开，如果抛出多个异常类型具有父子关系 ，直接声明父类即可。异常的捕获，也就是异常的具体处理方式，主要有两种：异常声明throws以及try-catch捕获处理。3、try可能会抛出多个不同的异常对象，则必须用多个catch来捕获，即多种异常，多次捕获。
异常之详解
wanggang182007的博客
01-04 162
定义：软件运行过程中，遇到输入不符合要求，程序打不开文件（文件可能不存在或格式不对），空指针，内存或硬盘满了，网络连接失败，非法参数等等这些异常问题，称为异常，Exception。发生在程序运行期间。 简单分类： 1.检查性异常：无法预见，打开一个不存在文件 2.运行时异常：容易被忽略，比喻写没问题，运行出问题 3.错误ERROR：错误不是异常，容易被忽略，栈溢出，错误就出现了，编译是检查不到的。 异常体系结构： 1.Throwable是所有异常的超类 2.异常分两大类：Error和Excep
异常详解（超详细）
Maddoxzhi的博客
08-29 294
①如果一个方法在执行时可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表面该方法将不对这些异常进行处理，而由该方法的调用者负责处理。②在方法声明中用throws语句可以声明抛出异常的列表（可以是一个异常也可以是多个异常），throws后面的异常类型可以是方法中产生的异常类型，也可以是该异常类型的父类。②如果try代码块有可能有多个异常，可以使用多个catch分别捕获不同的异常，但要求子类异常写在前面，父类异常写在后面。//3、注意，如果没有发生异常，catch代码块不执行。.
java-异常详解
简洁是智慧的灵魂
09-28 1081
（一）异常出现的原因 （二）异常分类 （三）异常的使用
异常详解————（推荐学习JAVA使用）
WestBay1的博客
08-31 260
异常 ​ 异常就是程序生病，无法正常运行。 1.异常的体系 Throwable / \ Error Exception / \ Checked Runtime Exception Exception ​ Error：一般由虚拟机生产并脱出的，不受程序员控制 ​ Exception：一旦程序遇到异常，程序无法执行。 2
java进阶--异常对象的常用方法getMessage、printStackTrace
weixin_41988224的博客
07-12 437
getMessage（） 获取异常简单的描述信息 printStackTrace（） 打印异常追踪的堆栈信息 public static void main(String[] args) { NullPointerException e=new NullPointerException("空指针异常"); String msg=e.getMessage();//获取异常的信息，这个信息实际上就是构造方法上面String参数 System.out.printl
JAVA中异常的两个常用方法（getMessage 和 printStackTrace）
qq_42843172的博客
06-30 4827
JAVA中异常的两个常用方法 异常对象有两个重要的方法： 获取异常简单的描述信息：（获取调用异常构造方法时输入的String s） exception.getMessage() 打印异常追踪的堆栈信息： exception.printStackTrace() public class ExceptionTest05 { public static void main(String[] args) { NullPointerException npe = new NullPoi
java异常写法_java之异常详解
weixin_39965102的博客
02-12 786
一、什么是异常?异常就是有异于常态，和正常情况不一样，有错误出错。在java中，阻止当前方法或作用域正常运行的情况，称之为异常。二、异常体系Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception。Throwable分成了两个不同的分支：Error：它...
Java异常处理
面向对象的笔记
10-27 210
异常 总结 异常是程序编译或运行过程中产生的，阻止当前方法或作用域继续执行的问题；可以使用throw关键字抛出一个异常对象，异常也是一个对象，继承自Object基类，在堆中分配内存，如果一个方法想要在内部抛出非RunTimeException的异常，需要在定义方法时，使用throws关键字声明异常说明，可以只声明而不抛出，对于RunTimeException运行时异常，可以不做异常声明。异常声明在...
Java异常处理与File构造方法详解
当程序中发生异常时，Java运行时系统会自动创建一个异常对象来描述这个错误，并且可以采用两种方式处理异常： 1. 系统自动处理：如果异常没有被捕获，程序会立即停止，并显示错误信息。 2. 程序员主动干预：通过...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值