java学习笔记(12) 第12 章 - 异常-Exception

已于 2023-11-06 14:48:40 修改
阅读量375 收藏 2
点赞数
分类专栏： java 文章标签： 经验分享 信号处理 intellij-idea
于 2021-11-29 12:20:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50736744/article/details/121584273
版权

第12 章异常-Exception

12.1 实际问题、解决办法、异常介绍

  • 看个实际的问题和一段代码

运行下面的代码，看看有什么问题-> 引出异常和异常处理机制 Exception01.java

public static void main(String[] args) {
int num1 = 10;
int num2 = 0;
int res = num1 / num2;
System.out.println("程序继续运行....");
}

  • 解决方案-异常捕获

    对异常进行捕获，保证程序可以继续运行.
    使用try-catch

将该代码块->选中->快捷键 ctrl + alt + t -> 选中 try-catch
e.getMessage() 还可以输出异常信息

public class Exception01 {
    public static void main(String[] args)  {
        int num1 = 10;
        int num2 = 0;//Scanner();

        //解读
        //1. num1 / num2 => 10 / 0
        //2. 当执行到 num1 / num2 因为 num2 = 0, 程序就会出现(抛出)异常 ArithmeticException
        //3. 当抛出异常后，程序就退出，崩溃了 , 下面的代码就不再执行
        //4. 大家想想这样的程序好吗? 不好，不应该出现了一个不算致命的问题，就导致整个系统崩溃
        //5. java 设计者，提供了一个叫 异常处理机制来解决该问题
//        int res = num1 / num2;
        //如果程序员，认为一段代码可能出现异常/问题，可以使用try-catch异常处理机制来解决
        //从而保证程序的健壮性
        //将该代码块->选中->快捷键 ctrl + alt + t -> 选中 try-catch
        //6. 如果进行异常处理，那么即使出现了异常，程序可以继续执行
        try {
            int res = num1 / num2;
        } catch (Exception e) {
            //e.printStackTrace();
            System.out.println("出现异常的原因=" + e.getMessage());//输出异常信息
        }

        System.out.println("程序继续运行....");

    }
}
  • 异常介绍

基本概念：

Java语言中，将程序执行中发生的不正常情况称为“异常”。(开发过程中的语法错误和逻辑错误不是异常)

执行过程中所发生的异常事件可分为两大类

  1. Error(错误):Java虚拟机无法解决的严重问题。如:JVM系统内部错误、资源耗尽等严重情况。比如: StackOverflowError[栈溢出]和OOM(out of memory)， Error是严重错误,程序会崩溃。
  2. Exception:其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。例如空指针访问,试图读取不存在的文件,网络连接中断等等，Exception 分为两大类:运行时异常[程序运行时，发生的异常]和编译时异常[编程时,编译器检查出的异常]。

12.2 异常体系图一览

12.2.1 异常体系图

在这里插入图片描述
在这里插入图片描述

12.2.2 异常体系图的小结

  1. 异常分为两大类,运行时异常和编译时异常.
  2. 运行时异常，编译器检查不出来。一般是指编程时的逻辑错误，是程序员应该避免其出现的异常。java.lang.RuntimeException类及它的子类都是运行时异常
  3. 对于运行时异常，可以不作处理，因为这类异常很普遍，若全处理可能会对程序的可读性和运行效率产生影响
  4. 编译时异常,是编译器要求必须处置的异常。

12.3 常见的运行时异常、举例

  • 常见的运行时异常包括
  1. NullPointerException 空指针异常
  2. ArithmeticException 数学运算异常
  3. ArrayIndexOutOfBoundsException 数组下标越界异常
  4. ClassCastException 类型转换异常
  5. NumberFormatException 数字格式不正确异常 [ ]
  • 常见的运行时异常举例
  1. NullPointerException 空指针异常 NullPointerException_.java
    当应用程序试图在需要对象的地方使用null 时，也就是说，对象还没创建出来就去使用了。抛出该异常,看案例演示。
public class NullPointerException_ {
    public static void main(String[] args) {
        String name = null;
        System.out.println(name.length());
    }
}
  1. ArithmeticException 数学运算异常 ArithmeticException_.java
    当出现异常的运算条件时，抛出此异常。例如，一个整数“除以零”时，本文12.1的代码
  2. ArrayIndexOutOfBoundsException 数组下标越界异常
    用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引
public class ArrayIndexOutOfBoundsException_ {
    public static void main(String[] args) {
        int[] arr = {1,2,4};
        for (int i = 0; i <= arr.length; i++) { // <=不对
            System.out.println(arr[i]);
        }
    }
}
  1. ClassCastException 类型转换异常
    当试图将对象强制转换为不是实例的子类时，抛出该异常。例如，以下代码将生成一个ClassCastException
public class ClassCastException_ {
    public static void main(String[] args) {
        A b = new B(); //向上转型,OK
        B b2 = (B)b;//向下转型，这里是OK，因为b本来就指向B
        C c2 = (C)b;//b指向的对象转成C，不行，B和C没啥关系，这里抛出ClassCastException
    }
}
class A {}
class B extends A {}
class C extends A {}
  1. NumberFormatException 数字格式不正确异常
    当应用程序试图将字符串转换成一种数值类型，但该字符串不能转换为适当格式时，抛出该异常=> 使用异常我们可以确保输入是满足条件数字.
public class NumberFormatException_ {
    public static void main(String[] args) {
        String num = "1234"; //这是ok的
        String name = "Java教育";
        //将String 转成 int
        int num1 = Integer.parseInt(num);//这是ok的
        int name1 = Integer.parseInt(name);//抛出NumberFormatException
        System.out.println(num);//1234
    }
}

12.4 编译异常

  • 介绍
    编译异常是指在编译期间，就必须处理的异常，否则代码不能通过编译。

  • 常见的编译异常

    SQLException //操作数据库时,查询表可能发生异常
    IOException//操作文件时,发生的异常
    FileNotFoundException//当操作一个不存在的文件时，发生异常
    ClassNotFoundException//加载类,而该类不存在时,异常
    EOFException//操作文件,到文件末尾,发生异常
    illegalArguementException//参数异常

12.5 异常课堂练习

在这里插入图片描述

12.6 异常处理

  • 1. 基本介绍

    异常处理就是当异常发生时，对异常处理的方式。

  • 2. 异常处理的方式

    (1) try-catch-finally
    程序员在代码中捕获发生的异常，自行处理
    (2) throws
    将发生的异常抛出，交给调用者(方法)来处理,最顶级的处理者就是JVM

  • 3. 示意图

try-catch-finally处理机制示意图
try-catch-finally处理机制示意图
throws处理机制图
在这里插入图片描述

12.7 try-catch 异常处理

try-catch-finally 执行顺序小结

  1. 如果没有出现异常，则执行try块中所有语句,不执行catch块中语句,如果有finally，最后还需要执行finally里面的语句
  2. 如果出现异常，则try块中异常发生后，try块剩下的语句不再执行。将执行catch块中的语句，如果有finally,最后还需要执行finally里面的语句!
    注意：try-catch-finally，如果finally后边还有代码还是会执行的，try-finally不会执行后边的了。

12.7.1 try-catch 方式处理异常说明

  1. Java提供try和catch块来处理异常。try块用于包含可能出错的代码。catch块用于处理try块中发生的异常。可以根据需要在程序中有多个try…catch块。
  2. 基本语法
    try {
    //可疑代码
    //将异常生成对应的异常对象,传递给catch块}
    catch(异常){
    //对异常的处理}
    //如果没有finally,语法是可以通过的

12.7.2 try-catch 方式处理异常-注意事项

TryCatchDetail.java

  1. 如果异常发生了，则异常发生后面的代码不会执行，直接进入到catch块.
  2. 如果异常没有发生，则顺序执行try的代码块,不会进入到catch.
  3. 如果希望不管是否发生异常,都执行某段代码(比如关闭连接,释放资源等)则使用如下代码- finally {}
  4. 可以有多个catch语句，捕获不同的异常(进行不同的业务处理)，要求父类异常在后，子类异常在前，比如(Exception在后，NullPointerException在前),如果发生异常，只会匹配一个catch,案例演示
  5. 可以进行try-finally配合使用,这种用法相当于没有捕获异常，因此程序会直接崩掉/退出。应用场景，就是执行一段代码，不管是否发生异常，都必须执行某个业务逻辑。
    注意：try-catch-finally，如果finally后边还有代码还是会执行的，try-finally不会执行后边的了。

第1-3点细节代码：

public class TryCatchDetail {
    public static void main(String[] args) {
        //ctrl + atl + t
        try {
            String str = "南昌大学";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
            System.out.println("异常信息=" + e.getMessage());
        } finally {
            System.out.println("finally代码块被执行...");
        }
        System.out.println("程序继续...");
    }
}

第4点细节代码：

public class TryCatchDetail02 {
    public static void main(String[] args) {
        try {
            Person person = new Person();
            person = null;
            System.out.println(person.getName());//NullPointerException
            int n1 = 10;
            int n2 = 0;
            int res = n1 / n2;//ArithmeticException
        } catch (NullPointerException e) {
            System.out.println("空指针异常=" + e.getMessage());
        } catch (ArithmeticException e) {
            System.out.println("算术异常=" + e.getMessage());
        } catch (Exception e) {
            System.out.println(e.getMessage());
        } finally {
        }
    }
}
class Person {
    private String name = "jack";
    public String getName() {
        return name;
    }
}

第5点细节代码：

public class TryCatchDetail03 {
    public static void main(String[] args) {
        try{
            int n1 = 10;
            int n2 = 0;
            System.out.println(n1 / n2);
        }finally {
            System.out.println("执行了finally.."); //程序直接退出
        }
        System.out.println("程序继续执行..");//这一句不会执行了，但是try-catch-finally，如果finally后边还有代码还是会执行的，try-finally不会执行后边的了。
    }
}

12.7.3 异常处理课堂练习

  1. 题1 TryCatchExercise01.java
    在这里插入图片描述
  2. 题2 TryCatchExercise02.java
    在这里插入图片描述
  3. 题3TryCatchExercise03.java
    在这里插入图片描述
  4. 如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止
import java.util.Scanner;
public class TryCatchExercise04 {
    public static void main(String[] args) {
        //如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止
        //思路
        //1. 创建Scanner对象
        //2. 使用无限循环，去接收一个输入
        //3. 然后将该输入的值，转成一个int
        //4. 如果在转换时，抛出异常，说明输入的内容不是一个可以转成int的内容
        //5. 如果没有抛出异常，则break 该循环
        Scanner scanner = new Scanner(System.in);
        int num = 0;
        String inputStr = "";
        while (true) {
            System.out.println("请输入一个整数:"); //
            inputStr = scanner.next();
            try {
                num = Integer.parseInt(inputStr); //这里是可能抛出异常
                break;
            } catch (NumberFormatException e) {
                System.out.println("你输入的不是一个整数:");
            }
        }
        System.out.println("你输入的值是=" + num);
    }
}

12.8 throws 异常处理

  • 一、基本介绍
  1. 如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理,而由该方法的调用者负责处理。
  2. 在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。
  • 二、快速入门案例
    public static void readFile(String file) throws FileNotFoundException {
    读文件的操作可能产生FileNotFoundException类型的异常
    FilelnputStream fis = new FilelnputStream(“d://aa.txt”);
    }
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Throws01 {
    public static void main(String[] args) {
    }
    public void f2() throws FileNotFoundException,NullPointerException,ArithmeticException {
        //创建了一个文件流对象
        //解读:
        //1. 这里的异常是一个FileNotFoundException 编译异常
        //2. 使用前面讲过的 try-catch-finally
        //3. 使用throws ,抛出异常, 让调用f2方法的调用者(方法)处理
        //4. throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类Exception
        //5. throws 关键字后也可以是 异常列表, 即可以抛出多个异常
        FileInputStream fis = new FileInputStream("d://aa.txt");
    }
}
  • 三、注意事项和使用细节
  1. 对于编译异常，程序中必须处理，比如try-catch 或者throws
  2. 对于运行时异常,程序中如果没有处理,默认就是throws的方式处理[举例]
  3. 子类重写父类的方法时，对抛出异常的规定:子类重写的方法，所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常的类型的子类型[举例]
  4. 在throws过程中，如果有方法 try-catch,就相当于处理异常，就可以不必throws
  5. 方法B抛出的是运行异常，方法A在调用方法B时可以不用抛出运行异常，java中并不要求程序员显示处理,因为有默认处理机制；
    但是方法B如果抛出的是编译异常，方法A在调用方法B时必须抛出一个编译异常。
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ThrowsDetail {
    public static void main(String[] args) {
        f2();
    }
    public static void f2() /*throws ArithmeticException*/ {
        //1.对于编译异常，程序中必须处理，比如 try-catch 或者 throws
        //2.对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
        int n1 = 10;
        int n2 = 0;
        double res = n1 / n2;
    }

    public static void f1() throws FileNotFoundException {
        //这里大家思考问题 调用f3() 报错
        //解读
        //1. 因为f3() 方法抛出的是一个编译异常
        //2. 即这时，就要f1() 必须处理这个编译异常
        //3. 在f1() 中，要么 try-catch-finally ,或者继续throws 这个编译异常
        f3(); // 抛出异常
    }
    public static void f3() throws FileNotFoundException {
        FileInputStream fis = new FileInputStream("d://aa.txt");
    }

    public static void f4() {
        //解读:
        //1. 在f4()中调用方法f5() 是OK
        //2. 原因是f5() 抛出的是运行异常
        //3. 而java中，并不要求程序员显示处理,因为有默认处理机制
        f5();
    }
    public static void f5() throws ArithmeticException {

    }
}

class Father { //父类
    public void method() throws RuntimeException {
    }
}
class Son extends Father {//子类
    //3. 子类重写父类的方法时，对抛出异常的规定:子类重写的方法，
    //   所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常类型的子类型
    //4. 在throws 过程中，如果有方法 try-catch , 就相当于处理异常，就可以不必throws
    @Override
    public void method() throws ArithmeticException {
    }
}

12.9 手动抛出异常 throw

  • 一、基本介绍

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者 。

Java 异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可以根据需要使用人工创建并抛出。

在java中，提供了一个 throw 关键字，它用来抛出一个指定的异常对象。 在当前方法中不处理，抛给调用者处理。
　　
　 异常的对象的创建和抛出有两种方式：
（1）JVM 创建并抛出
（2）手动 new 出来，然后由 throw 抛出。

Throwable：只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出。

类似地，只有此类或其子类之一才可以是 catch 子句中的参数类型。

手动抛出异常对象：
（1）首先要生成异常类对象，然后通过 throw 语句实现抛出操作（提交给 Java 运行环境）

IOException e = new IOException();
throw e；

（2）可以抛出的异常必须是 Throwable 或其子类的实例。下面的语句在编译时将会产生语法错误：

throw new String("want to throw");

  • 二、throw抛出异常实现步骤

    （1）创建一个异常对象。封装一些提示信息（信息可以自己编写）
    （2）需要将这个异常对象告诉给调用者。通过关键字 throw 就可以完成。throw 异常对象。

使用格式： throw new 异常类名(“异常产生的原因(自己编辑)”);

  • 三、 throw 关键字作用
    用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
    注意事项：
    （1）throw 关键字必须写在方法的内部
    （2）throw 关键字后边 new 的对象必须是 Exception或者Exception的子类对象
    （3）throw 关键字抛出指定的异常对象,我们就必须处理这个异常对象
    （4）throw 关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
    （5）throw 关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try…catch

  • 四、throw 与 throws 区别

面试题：throw 与 throws 有什么区别？
（1）throw 用于手动抛出异常对象，是个可执行的语句
（2）throws：在方法签名中，声明方法可能抛出什么异常，让调用者来处理这些异常。

12.10 自定义异常

  • 一、基本概念
    当程序中出现了某些“错误”，但该错误信息并没有在Throwable子类中描述处理，这个时候可以自己设计异常类，用于描述该错误信息。

  • 二、自定义异常的步骤

  1. 定义类:自定义异常类名(程序员自己写)继承Exception或RuntimeException
  2. 如果继承Exception，属于编译异常
  3. 如果继承RuntimeException，属于运行异常(一般来说，继承RuntimeException)
  • 三、自定义异常的应用实例 CustomException.java
    当我们接收Person对象年龄时，要求范围在18-120之间，否则抛出一个自定义异常(要求继承RuntimeException)，并给出提示信息。
public class CustomException {
    public static void main(String[] args) /*throws AgeException*/ {

        int age = 180;
        //要求范围在 18 – 120 之间，否则抛出一个自定义异常
        if(!(age >= 18 && age <= 120)) {
            //这里我们可以通过构造器，设置信息
            throw new AgeException("年龄需要在 18~120之间");
        }
        System.out.println("你的年龄范围正确.");
    }
}
//自定义一个异常
//解读
//1. 一般情况下，我们自定义异常是继承 RuntimeException
//2. 即把自定义异常做成 运行时异常，好处是，我们可以使用默认的处理机制
//3. 即比较方便
class AgeException extends RuntimeException {
    public AgeException(String message) {//构造器
        super(message);
    }
}

运行结果如下图所示：
在这里插入图片描述

12.11 throw 和throws 的区别

  • 一览表
    在这里插入图片描述
  • 测试题-下面的测试输出什么 ThrowException.java 2min
    在这里插入图片描述

12.12 本章作业

  1. 编程题 Homework01.java
    a)编写应用程序EcmDef.java，接收命令行的两个参数(整数)，计算两数相除。
    b)计算两个数相除,要求使用方法cal(int n1, int n2)
    c)对数据格式不正确(NumberformatException)、缺少命令行参数(ArraylndexOutOfBoundsException)、除0进行异常处理(ArithmeticException)。

注意：本代码用到了之前的文章 https://blog.csdn.net/m0_50736744/article/details/121450090?spm=1001.2014.3001.5501 中10.2 理解main 方法语法 -深入理解main方法的args

public class Homework01 {
    public static void main(String[] args) {
    
        try {
            //先验证输入的参数的个数是否正确 两个参数
            if(args.length != 2) {
                throw new ArrayIndexOutOfBoundsException("参数个数不对");
            }

            //先把接收到的参数，转成整数
            int n1 = Integer.parseInt(args[0]);
            int n2 = Integer.parseInt(args[1]);

            double res = cal(n1, n2);//该方法可能抛出ArithmeticException
            System.out.println("计算结果是=" + res);

        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e.getMessage());
        } catch (NumberFormatException e) {
            System.out.println("参数格式不正确，需要输入整数");
        } catch (ArithmeticException e) {
            System.out.println("出现了除0的异常");
        }
    }
    //编写cal方法，就是两个数的商
    public static double cal(int n1, int n2) {
        return n1 / n2;
    }
}
  1. 第2题，说出以下代码是否会发生异常，如果会，是哪种异常?如果不会，则打印结果是什么？
public class Homework02 {
    public static void main(String[] args) {
		
        if(args[4].equals("john")){  //可能发生ArrayIndexOutOfBoundsException，
                                 //因为一开始args.length = 0,或者一开始传的值不5个
            System.out.println("AA");
        }else{
            System.out.println("BB");
        }
        Object o= args[2]; //String->Object ，向上转型
        Integer i = (Integer)o; //错误，这里一定会发生 ClassCastException,因为上边是字符串赋给了o，这里把字符串o转换为整数不对
    }
}
  1. 第3题
    在这里插入图片描述
  2. 第4题
    在这里插入图片描述
码农小C
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
如何优雅的解决java.lang.NullPointerException 空指针的问题
weixin_39098944的博客
06-15 4044
背景 每次拿到对象在进行相关方法或属性的时候都要进行如下操作 先判断是否为null if(obj!=null){ //todo....... }else{ //todo } 这样的代码，既繁琐，又影响阅读性，否则，一不小心就会报如下错误信息 D:\Java\jdk1.8.0_202\bin\java.exe "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2018.3.5\lib\idea_rt.jar=55047:C:\Progra
Java 基础 第2阶段：面向对象编程-尚硅谷学习笔记（含面试题） 2023年
05-09
面向对象编程是Java的核心特性，本学习笔记涵盖了这一主题的深度探索，旨在帮助开发者深入理解并熟练运用面向对象的思想。2023年的版本更新可能包含最新的面试趋势和技术发展。以下将详细介绍Java面向对象编程的一些...
Java语言程序设计与数据结构（基础篇）课后练习题 第十二章（二）
IT_Holmes的博客
12-21 3783
12.8 本來想用上一題的老办法，但是这个题要自定义异常，没法用。。。 import java.util.Scanner; public class dishierzhang { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); try { System.out.print("Enter a hex string: "
Java的第一遍学习笔记 异常处理
Acc222222的博客
09-27 167
如果没有使用异常处理机制，当抛出异常后，程序就退出了，下面的代码就不再执行。这样就导致一个不算致命的问题就会引起整个系统的崩溃，这使得程序的健壮性很差。因此，Java的设计者提供了一个异常处理机制 来解决这个问题。 如果程序员认为一段代码可能出现异常/问题，可以使用 try-catch 异常处理机制来解决，将该代码块选中 -> 快捷键 ctrl + alt + t -> 选中 try-catch。这样即使出现异常，程序也会继续执行。 异常 基本概念 ...
File throws NullPointerException
小风筝
06-20 1054
File类 一个File类的对象，表示磁盘上的文件或目录，实际上，用FilePath（文件路径）对这个类来说是个更好的名字。 File类没有指定信息怎么从文件读取或者向文件存储 先看File 的源代码/** * Creates a new <code>File</code> instance by converting the given * pathname string
自定义异常为什么要继承RuntimeException
最新发布
weixin_49302930的博客
07-05 692
在Java中，异常分为受检异常（Checked Exception）和运行时异常（Unchecked Exception）两种类型。受检异常需要在方法上显式声明或捕获，而运行时异常则不需要。当我们自定义异常时，通常会选择继承不需要在方法签名中声明：由于运行时异常不需要在方法上显式声明或捕获，所以继承的自定义异常可以在方法中抛出而无需修改方法签名。异常不需要被强制捕获：运行时异常不需要被强制捕获，开发者可以选择是否捕获并处理这些异常。这样可以减少代码的冗余性，简化异常处理逻辑。
java学习笔记－基础
12-23
### Java学习笔记——基础知识详解 #### 一、Java开发环境(JDK)与运行环境(JRE) Java技术的核心在于其强大的跨平台能力，这主要得益于Java的两大环境：JDK（Java Development Kit）和JRE（Java Runtime ...
Java学习笔记-个人整理的
12-19
{12}Oracle数据库}{151}{chapter.12} {12.1}术语}{151}{section.12.1} {12.2}登录数据库}{151}{section.12.2} {12.3}创建表格}{152}{section.12.3} {12.4}关于null值}{154}{section.12.4} {12.5}操作符与实例}...
java学习笔记
04-26
在Java编程语言中，有许多核心概念和特性，这些知识点对于理解和掌握Java编程至关重要。以下是一些基于标题、...以上就是Java学习笔记中涉及的一些关键知识点，理解并熟练运用这些知识是成为合格的Java程序员的基础。
C#编程学习笔记_C#编程学习笔记_
10-02
4. **异常处理（Exception Handling）**：C#中的try-catch-finally结构用于处理运行时错误，确保程序在遇到问题时能够优雅地恢复或结束。 5. **集合与泛型（Collections and Generics）**：了解ArrayList、...
为什么throw null会抛出NullPointerException？
swordinhand的专栏
02-18 1601
看招聘区的联创面试题想到的这个问题，一开始还以为是因为异常链无法获取到null的信息导致的，后来上网搜了一下，有篇帖子[url]http://www.adarshr.com/papers/npe[/url]解释了这个问题，这其实是Java语言规范里指定的内容，在Java Language Specification第三版$14.18 The throw Statement里面提到了 “A thr...
Java自定义异常，应该继承Exception还是Runtime Exception，为什么？
Feng_ZiYou的博客
01-07 4630
Exception分为编译时异常和运行时异常，编译时异常也叫做checkedException,运行时异常也叫做uncheckedException 如果抛出Exception，比如throw new Exception(“error message”);则必须要对该异常进行处理，要么自己try catch,要么使用throws语句在方法上抛出给调用者，让调用者去处理，而且调用者必须处理，否则编译不会通过，这样的好处是出现该异常时由于调用方处理了，所以程序不会停止运行，缺点是耦合性太高了，如果不throws
解决JavaScript validator throws NullPointerException in Eclipse问题
轻舟泛水
03-31 591
Project->Properties->Builders then disable ‘Javascript Validator
Java异常处理——抛出异常&自定义异常&NullPointerException
weixin_44432569的博客
08-26 7126
目录小结抛出异常异常的传播抛出异常异常屏蔽提问时贴出异常自定义异常NullPointerException处理NullPointerException定位NullPointerException 小结 调用printStackTrace()可以打印异常的传播栈，对于调试非常有用； 捕获异常并再次抛出新的异常时，应该持有原始异常信息； 通常不要在finally中抛出异常。如果在finally中抛出异常，应该原始异常加入到原有异常中。调用方可通过Throwable.getSuppressed()获取所有添加的
Java Exception - 异常类的继承体系
你今天真好看呀
05-05 8381
文章目录1. 异常类的继承体系2. Error错误3. Exception异常3.1 编译时异常： Checked Exception3.2 运行时异常：Runtime Exception 1. 异常类的继承体系 Java把所有的非正常情况分成两种：异常（Exception）和错误（Error），它们都继承Throwable父类。 2. Error错误 Error错误，一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢复或不可能捕获，将导致应用程序中断。通常应用程序无法处理
Java编程基础入门：第1-18章学习笔记
此外，理解面向对象编程的概念，如继承、多态性和封装，也是Java学习的核心部分。随着学习的深入，还将探索更高级的主题，如集合框架、I/O流、网络编程以及多线程等。 通过这份1-18章的教程，学习者将逐步建立起对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农小C

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值