Java异常处理--throw手动抛出异常对象

已于 2024-01-17 17:36:49 修改
阅读量4.1k 收藏 34
点赞数 39
分类专栏： Java基础 文章标签： java 异常处理 throw 手动抛出异常对象
于 2024-01-17 17:36:31 首次发布
不要随意搬运哦，私信博主同意之后再转载~
本文链接：https://blog.csdn.net/m0_55746113/article/details/135656358
版权

文章目录

一、手动抛出异常对象：throw

（1）两种方式

之前说的几个步骤：

①此时执行几行代码，在执行的过程中，可能出现一些问题，比如将字符串“abc”转换成Integer类型的，肯定是没有办法转化。这时候它会在相应代码位置自动生成一个NumberFormatException的对象，这个对象就被抛出去了。

②针对抛出的异常对象，考虑catch处理（捕获）；若是搞不定，还可以throws。（异常处理的两种方式）

现在针对“生成异常对象”的环节，除了系统自动抛之外，可能还会出现手动抛出异常对象的场景。

手动抛出异常对象，也是要处理的。只要是抛出了异常对象，不去处理的话，程序就会停止。

☕Java 中异常对象的生成有两种方式：

  • 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，那么针对当前代码，就会在后台自动创建一个对应异常类的实例对象并抛出。
  • 由开发人员手动创建：new 异常类型([实参列表]);，如果创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样，但是一旦throw抛出，就会对程序运行产生影响了。

🎲为什么要主动抛出异常呢？

在程序执行的时候，有时候会出现不满足要求的场景。比如将字符串“abc”转换为Integer类型的，这就是转换不了的，对于这种场景，程序给我们预知道这些问题，帮我们把这些问题给操作了，意思就是，若是出现这种不合理的现象，它就会自动抛出一个异常对象。
但是还是会有一些实际问题，系统没办法给我们抛，就需要自己来。

比如现在有一个Student，他有一个id属性，要给id赋值，这个id最起码要是一个正数，一旦给这个id赋值了负数，就不太合理。以前我们是写一个输出语句，现在可以拋一个异常。在Java语言层面，没有说id不能是负数，这是我们实际情况需要的一个要求。

所以，如果在实际开发当中，有一些具体的要求，这些要求在实际操作中不满足的时候，我们就可以主动去抛出一个异常对象。

在实际开发中，如果出现不满足具体场景的代码问题，我们就有必要手动抛出一个指定类型的异常对象。

（2）使用格式

🎲如何实现手动抛出异常？

在方法内部，满足指定条件的情况下，使用"throw 异常类的对象"的方式抛出。

注意这里是throw，后面是异常的对象，既然是对象，就需要new一个，后面再跟上想抛出类型的异常。

如下：

throw new 异常类名(参数);

注意点：throw后的代码不能被执行，编译不通过。

throw语句抛出的异常对象，和JVM自动创建和抛出的异常对象一样。

  • 如果是编译时异常类型的对象，同样需要使用throws或者try…catch处理，否则编译不通过。
  • 如果是运行时异常类型的对象，编译器不提示。
  • 可以抛出的异常必须是Throwable或其子类的实例。下面的语句在编译时将会产生语法错误：
throw new String("want to throw");

（3）举例

1、手动抛运行时异常

现在有一个Student，他有一个id属性，要给id赋值，这个id最起码要是一个正数，一旦给这个id赋值了负数，就不太合理。

以前我们是写一个输出语句，现在可以拋一个异常。在Java语言层面，没有说id不能是负数，这是我们实际情况需要的一个要求。

以往我们只能这样表示id输入非法（输入的是负数），如下：

public class ThrowTest {

}

class Student{
    int id;

    public void regist(int id){
        if(id>0){
            this.id=id;
        }else{
            System.out.println("输入的id非法");
        }
    }
}

现在我们可以手动抛出异常类的对象，一旦输入的id不行，就不让程序继续往下执行，如下：

class Student{
    int id;

    public void regist(int id){
        if(id>0){
            this.id=id;
        }else{
            //System.out.println("输入的id非法");

            //手动抛出异常类的对象
            throw new RuntimeException("输入的id非法");
        }
    }
}

这里抛的是一个运行时异常，抛出了一个异常对象，下一步就需要考虑处理了，运行时异常可以考虑不处理。

所以现在不需要try-catch或者throws。

调用一下：

🌱情况1

package yuyi02;

public class ThrowTest {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.regist(10);
        System.out.println(s1);
    }
}

class Student{
    int id;

    public void regist(int id){
        if(id>0){
            this.id=id;
        }else{
            //System.out.println("输入的id非法");

            //手动抛出异常类的对象
            throw new RuntimeException("输入的id非法");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
        "id=" + id +
        '}';
    }
}

输出结果：

image.png

这是一个正常情况。

🌱情况2

package yuyi02;

public class ThrowTest {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.regist(-10);
        System.out.println(s1);
    }
}

class Student{
    int id;

    public void regist(int id){
        if(id>0){
            this.id=id;
        }else{
            //System.out.println("输入的id非法");

            //手动抛出异常类的对象
            throw new RuntimeException("输入的id非法");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
        "id=" + id +
        '}';
    }
}

此时传入regist中的是-10，会进入else逻辑中，会抛出异常对象。

这个异常对象抛出来之后也没有进行处理，也没有try-catch-finally，也没有throws。（运行时异常不做处理）

所以，这个时候出现的异常对象，导致程序终止，main方法后面的输出语句就无法执行了。

看一下输出结果：

image.png

可以看到，它里面是一个RuntimeException，因为我们造的就是一个RuntimeException的对象，里面的信息就是"输入的id非法"。我们在这里写的信息其实就是Message里面的内容。

☕补充

若是现在处理这个“运行时异常”，可以这样try-catch一下：

package yuyi02;

public class ThrowTest {
    public static void main(String[] args) {
        Student s1=new Student();
        try {
            s1.regist(-10);
            System.out.println(s1);
        }catch (RuntimeException e){
            e.printStackTrace();
        }

    }
}

class Student{
    int id;

    public void regist(int id){
        if(id>0){
            this.id=id;
        }else{
            //手动抛出异常类的对象
            throw new RuntimeException("输入的id非法");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
        "id=" + id +
        '}';
    }
}

输出结果和没有处理的时候一样，所以说一般不做处理，如下：

image.png

这里的“输入的id非法”其实就是getMessage，它里面就是构造器传进来的数据。

public class ThrowTest {
    public static void main(String[] args) {
        Student s1=new Student();
        try {
            s1.regist(-10);
            System.out.println(s1);
        }catch (RuntimeException e){
            System.out.println(e.getMessage());
        }
    }
}

class Student{
    int id;

    public void regist(int id){
        if(id>0){
            this.id=id;
        }else{
            //System.out.println("输入的id非法");

            //手动抛出异常类的对象
            throw new RuntimeException("输入的id非法");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
        "id=" + id +
        '}';
    }
}

现在打印的就是这个内容，如下：

image.png

2、手动抛普通的异常

比如这样：

package yuyi02;

class Student{
    int id;

    public void regist(int id){
        if(id>0){
            this.id=id;
        }else{
            //2、手动抛出异常类的对象--普通异常
            throw new Exception("输入的id非法");
        }
    }
}

这个时候就要小心一点了，因为它不是运行时异常了，这种运行方式就需要处理了。如下：

image.png

出了异常就要处理了，可以try-catch或者throws。

假设现在不在regist方法里面try-catch，那我们就throws一下。

因为下面thow的是一个Exception，那么上面throws的也要是Exception。如下：

image.png

现在不是运行时异常，就需要处理了。

现在是一个普通的Exception，而且将这个问题抛到main方法那边了。main方法就需要处理这个异常了，这时候必须要try-catch（catch里面的异常就是针对throw过来的那个，现在throw过来了Exception，所以catch里面要写Exception），如下：

public class ThrowTest {
    public static void main(String[] args) {
        Student s1=new Student();

        //2、手动抛出异常类的对象--普通异常 (非运行时异常)
        try {
            s1.regist(-10);
            System.out.println(s1);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

🌱整体代码

package yuyi02;

public class ThrowTest {
    public static void main(String[] args) {
        Student s1=new Student();

        //2、手动抛出异常类的对象--普通异常 (非运行时异常)
        try {
            s1.regist(-10);
            System.out.println(s1);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

class Student{
    int id;

    public void regist(int id) throws Exception{
        if(id>0){
            this.id=id;
        }else{

            //2、手动抛出异常类的对象--普通异常 (非运行时异常)
            throw new Exception("输入的id非法");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                '}';
    }
}

注意点：throw后的代码不能被执行，编译不通过。比如：

image.png

🍺输出如下

image.png

3、代码

上面两种的代码，整体如下：

🌱代码

package yuyi02;

/**
 * ClassName: ThrowTest
 * Package: yuyi02
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2024/1/16 0016 11:39
 */
public class ThrowTest {
    public static void main(String[] args) {
        Student s1=new Student();

        //1、手动抛出异常类的对象--运行时异常
        /*
        try {
            s1.regist(-10);
            System.out.println(s1);
        }catch (RuntimeException e){
            //e.printStackTrace();
            System.out.println(e.getMessage());
        }*/


        //2、手动抛出异常类的对象--普通异常 (非运行时异常)
        try {
            s1.regist(-10);
            System.out.println(s1);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}

class Student{
    int id;

    public void regist(int id) throws Exception{
        if(id>0){
            this.id=id;
        }else{
            //System.out.println("输入的id非法");

            //1、手动抛出异常类的对象--运行时异常
            //throw new RuntimeException("输入的id非法");

            //2、手动抛出异常类的对象--普通异常 (非运行时异常)
            throw new Exception("输入的id非法");
        }
    }

    @Override
    public String toString() {
        return "Student{" +
        "id=" + id +
        '}';
    }
}

（4）使用注意点

无论是编译时异常类型的对象，还是运行时异常类型的对象，如果没有被try…catch合理的处理，都会导致程序崩溃。

throw语句会导致程序执行流程被改变，throw语句是明确抛出一个异常对象，因此它下面的代码将不会执行。

如果当前方法没有try…catch处理这个异常对象，throw语句就会代替return语句提前终止当前方法的执行，并返回一个异常对象给调用者。

package com.atguigu.keyword;

public class TestThrow {
    public static void main(String[] args) {
        try {
            System.out.println(max(4,2,31,1));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max(4));
        } catch (Exception e) {
            e.printStackTrace();
        }
        try {
            System.out.println(max());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static int max(int... nums){
        if(nums == null || nums.length==0){
            throw new IllegalArgumentException("没有传入任何整数，无法获取最大值");
        }
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if(nums[i] > max){
                max = nums[i];
            }
        }
        return max;
    }
}

（5）自动VS手动

🎲如何理解"自动 vs 手动"抛出异常对象？

①过程1：“抛”（产生异常对象）

  • “自动抛” ： 程序在执行的过程当中，一旦出现异常，就会在出现异常的代码处，自动生成对应异常类的对象，并将此对象抛出。一旦抛出，此程序就不执行其后的代码了。
  • “手动抛” ：程序在执行的过程当中，不满足指定条件的情况下，我们主动的使用"throw + 异常类的对象"方式抛出异常对象。

②过程2：“抓” （处理异常对象）

  • 狭义上讲：try-catch的方式捕获异常，并处理。
  • 广义上讲：把“抓”理解为“处理”。则此时对应着异常处理的两种方式：① try-catch-finally ② throws

☕注意

1、其实，所谓的自动抛，不过不是我们自己写的而已。在源码中，它其实也是用“throw+异常对象”来做的。这里只是理解为“自动抛”。

2、throws和throw是合作关系，throws是产生异常对象的过程，throw是处理异常对象的过程。

二、练习

（1）练习1

🌋题目描述

修改chapter08_oop3中接口部分的exer2，在ComparableCircle接口compareTo()中抛出异常。

在接口这一篇的练习2中有详细说明，链接：https://blog.csdn.net/m0_55746113/article/details/134687578?spm=1001.2014.3001.5502

image.png

【Circle.java】

package yuyi02.exer.exer1;

/**
 * ClassName: Circle
 * Package: yuyi03
 * Description:
 *      定义一个Circle类，声明radius属性，提供getter和setter方法
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 14:52
 */
public class Circle {   //两个Circle对象不能够比较大小
    public double radius;   //半径

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public Circle() {

    }

    public Circle(double radius) {
        this.radius = radius;
    }

    //toString方法
    @Override
    public String toString() {
        return "Circle{" +
        "radius=" + radius +
        '}';
    }
}

【ComparableCircle.java】

package yuyi02.exer.exer1;

/**
 * ClassName: ComparableCircle
 * Package: yuyi03
 * Description:
 *      定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。
 *      在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 14:56
 */
public class ComparableCircle extends Circle implements CompareObject {
    //根据对象半径的大小，比较对象的大小(和之前说的equals很像)
    @Override
    public int compareTo(Object o) {
        if(this==o){    //判断当前对象与o是不是指向同一个
            return 0;   //若地址一样，则半径肯定一致，直接返回0
        }
        if(o instanceof ComparableCircle){  //判断是否是当前类的对象
            ComparableCircle c=(ComparableCircle) o;    //若是当前类对象，先强转一下 (从父类对象强转成子类才能调用子类特有的结构)
            return Double.compare(this.getRadius(),c.getRadius()); //API里面有一个类就叫Double，里面有一个方法叫compare()，里面传入两个double类型的值，就会自动比较它们的大小，返回的就是一个int类型的值，直接return即可

        }else{  //当这个对象不是当前实例
            //return 2;  如果输入类型不匹配，则返回2
            throw new RuntimeException("输入类型不匹配");
        }

    }

    public ComparableCircle() {

    }

    public ComparableCircle(double radius) {
        super(radius);
    }
}

【CompareObject.java】

package yuyi02.exer.exer1;

/**
 * ClassName: CompareObject
 * Package: yuyi03
 * Description:
 *      定义一个接口用来实现两个对象的比较。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 10:09
 */
public interface CompareObject {    //自定义一个接口来比较对象大小
    //若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
    public int compareTo(Object o); //这个是抽象方法(省略了abstract)，虽然它没有方法体，但是这个方法是做什么的，形参是什么意思，返回值类型是什么都完全确定了，只是细节没有确定
}

【InterfaceTest.java】

package yuyi02.exer.exer1;

/**
 * ClassName: InterfaceTest
 * Package: yuyi03
 * Description:
 *      定义一个测试类InterfaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 15:43
 */
public class InterfaceTest {
    public static void main(String[] args) {
        ComparableCircle c1=new ComparableCircle(2.3);
        ComparableCircle c2=new ComparableCircle(5.3);

        int compareValue=c1.compareTo(c2);
        if(compareValue>0){
            System.out.println("c1对象大");
        } else if (compareValue<0) {
            System.out.println("c2对象大");
        }else {
            System.out.println("c1与c2一样大");
        }
    }
}

🍰分析

接口CompareObject里面有一个方法compareTo，用来比较对象大小。

Circle本身不能比较大小，它的子类ComparableCircle继承于Circle的同时又实现了接口CompareObject，它就具备了比较大小的规范。

在ComparableCircle中将方法compareTo重写了。

若比较的两者一致就是0。

不一致的话，若是ComparableCircle类型的，先强转然后比较；若不是ComparableCircle类型的，当时没有学到异常，只能用return 2将就一下，现在来看的话，不是ComparableCircle类型的就直接抛一个异常即可。

如下：

image.png

这时候，抛一个异常最为合适，因为返回正数、负数、0都不太合适。

现在抛的是运行时异常RuntimeException，抛了一个对象而已，此时并没有处理。

一般抛出异常之后，都考虑要进行处理，只不过此时抛的是运行时异常，就不用进行处理了。

若此时用的是一般异常，就需要进行处理了。比如现在throw了一个Exception，如下：

image.png

现在就要处理了，要不然程序过不去。

怎么处理？要么throws，要么try-catch。

比如现在往上抛，针对当前抛的类型，也应该是Exception，如下：

image.png

这时候怎么还报错呢？

看一下错误信息：

image.png

这是因为接口里面没有抛异常，如下：

image.png

实现方法（重写方法）里面不能抛比接口里面更大的，所以此时接口里面也需要做处理：

image.png

以后也会碰见这样的场景，在接口里面，明明是一个抽象方法，它也会抛出一个异常，这就是为了配合在具体实现的时候可能会抛出的异常。

现在还有一个地方报错，如下：

image.png

这是因为刚才处理异常的时候，我们采用了第二种方式，就是throws往上抛。

所以在main方法里面，就必须要对异常进行处理了。

可以使用try-catch进行处理，如下：

image.png

🌱代码

【Circle.java】

package yuyi02.exer.exer1;

/**
 * ClassName: Circle
 * Package: yuyi03
 * Description:
 *      定义一个Circle类，声明radius属性，提供getter和setter方法
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 14:52
 */
public class Circle {   //两个Circle对象不能够比较大小
    public double radius;   //半径

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public Circle() {

    }

    public Circle(double radius) {
        this.radius = radius;
    }

    //toString方法
    @Override
    public String toString() {
        return "Circle{" +
        "radius=" + radius +
        '}';
    }
}

【CompareObject.java】

package yuyi02.exer.exer1;

/**
 * ClassName: CompareObject
 * Package: yuyi03
 * Description:
 *      定义一个接口用来实现两个对象的比较。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 10:09
 */
public interface CompareObject {    //自定义一个接口来比较对象大小
    //若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
    public int compareTo(Object o) throws Exception; //这个是抽象方法(省略了abstract)，虽然它没有方法体，但是这个方法是做什么的，形参是什么意思，返回值类型是什么都完全确定了，只是细节没有确定
}

【ComparableCircle.java】

package yuyi02.exer.exer1;

/**
 * ClassName: ComparableCircle
 * Package: yuyi03
 * Description:
 *      定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口。
 *      在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 14:56
 */
public class ComparableCircle extends Circle implements CompareObject {
    //根据对象半径的大小，比较对象的大小(和之前说的equals很像)
    @Override
    public int compareTo(Object o) throws Exception{
        if(this==o){    //判断当前对象与o是不是指向同一个
            return 0;   //若地址一样，则半径肯定一致，直接返回0
        }
        if(o instanceof ComparableCircle){  //判断是否是当前类的对象
            ComparableCircle c=(ComparableCircle) o;    //若是当前类对象，先强转一下 (从父类对象强转成子类才能调用子类特有的结构)
            return Double.compare(this.getRadius(),c.getRadius()); //API里面有一个类就叫Double，里面有一个方法叫compare()，里面传入两个double类型的值，就会自动比较它们的大小，返回的就是一个int类型的值，直接return即可

        }else{  //当这个对象不是当前实例
            //throw new RuntimeException("输入类型不匹配");
            throw new Exception("输入的类型不匹配");
        }

    }

    public ComparableCircle() {

    }

    public ComparableCircle(double radius) {
        super(radius);
    }
}

【InterfaceTest.java】

package yuyi02.exer.exer1;

/**
 * ClassName: InterfaceTest
 * Package: yuyi03
 * Description:
 *      定义一个测试类InterfaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。
 * @Author 雨翼轻尘
 * @Create 2023/11/28 0028 15:43
 */
public class InterfaceTest {
    public static void main(String[] args) {
        ComparableCircle c1=new ComparableCircle(2.3);
        ComparableCircle c2=new ComparableCircle(5.3);

        try {
            int compareValue=c1.compareTo(c2);
            if(compareValue>0){
                System.out.println("c1对象大");
            } else if (compareValue<0) {
                System.out.println("c2对象大");
            }else {
                System.out.println("c1与c2一样大");
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }
}

🍺输出结果

image.png

（2）面试题

🎲面试题：throw 和 throws 的区别？

答：“上游排污，下游治污”，污-异常对象；排-throw；治-throws。

throws从使用上来讲，是使用在方法的声明上，后面跟异常类型，指明将异常向上一层抛出，属于异常处理的方式。

throw是使用在方法内部，后面跟的是异常类的对象，表示手动抛出一个指定异常类的对象。

throw用来产生异常对象（第一个环节），throws是针对产生的异常对象，如何进行处理（第二个环节）。

雨翼轻尘
关注
  • 39
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java千百问_04异常处理（003）_如何抛出异常
幽灵雾的专栏
04-08 6084
java如何抛出异常 抛出异常使用throws/throw关键字。 throws关键字是什么 throws用来声明某一个方法可能抛出的异常，这个异常可以是系统定义的，也可以是自己定义的。 调用throws修饰的方法，必须要对其做异常处理或者将异常继续声明抛出（使用throws）。
java 手动抛异常_Java 异常处理 之 手动抛出异常
热门推荐
weixin_39719989的博客
02-19 1万+
一、手动抛出异常 throw在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者 。Java 异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可以根据需要使用人工创建并抛出。在java中，提...
Java-手动抛出异常
ispringmw的博客
04-26 5424
Java-手动抛出异常 1.概念 关于异常对象的产生 系统自动生成的异常对象 手动生成一个异常对象，并抛出（throw） 2.code举例 package p8exception.p9; public class StudentTest { public static void main(String[] args) { Student s = new Student(); try { s.regist(-1001);
【Java】抛出异常
最新发布
qq_39921135的博客
07-10 555
当代码真的出现这个异常了，我们需要将异常交给调用者处理，此时调用者是不能直接不管的，因此这样的话最终就会将异常交给虚拟机处理，虚拟机的处理方案就是：停止程序，并把异常信息打印在控制台，这种方式的弊端就是：下面的代码就执行不了了，程序会结束。写在方法内，表示结束方法，用来手动抛出异常对象，将异常对象交给调用者处理，方法中下面的代码不会再执行了。因此这两个异常都是运行时异常，运行时异常我们是不需要手动声明的，这个可以省略不写。，如果有多个异常，那么异常与异常之间应该使用逗号来进行隔开。以前我们是下面这样写的。
手动抛出异常 [Java][概述]
m0_57001006的博客
11-13 674
手动抛出异常 关于异常对象的产生: 系统自动生成的异常对象 手动的生成一个异常对象,并且抛出(throw) throw手动抛出异常 eg: class Student{ private int id; public void regist(int id){ if(id>0){ this.id=id; }else{ /* 我们以前使用的方式: System.
手动抛出异常对象
小涛今天没敲代码的博客
11-14 242
文章目录手动抛出异常对象1. 使用说明2. [面试题]3. 典型例题 b站学习视频以及笔记-尚硅谷_Java零基础教程 java入门必备-适合初学者的全套完整版教程(宋红康主讲) 手动抛出异常对象 1. 使用说明 在程序执行中，除了自动抛出异常对象的情况之外，我们还可以手动的throw一个异常类的对象。 2. [面试题] throw 和 throws区别： throw 表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。 throws 属于异常处理的一种方式，声明在方法的声明处。 3. 典
Java异常处理-throw手动抛出异常对象
01-17
通过以上内容，我们可以看到Java异常处理中的throw关键字用于手动抛出异常对象，这在处理不符合业务逻辑或预期情况时非常有用。理解并熟练运用异常处理机制，可以显著提升程序的稳定性和可靠性。
Java异常处理-异常处理知识点总结及企业真题
01-18
另外，`throw`关键字可以用来手动抛出异常对象，这通常发生在检测到程序状态异常或用户输入错误时。 自定义异常是扩展Java异常处理能力的一个重要方面。通过创建继承自`Exception`或其子类的新类，可以定义特定于...
Java编程中使用throw关键字抛出异常的用法简介
09-03
`throw`关键字是Java中用于手动抛出异常的关键字，通常在检测到某个条件不符合预期或者需要提供特定错误信息时使用。以下是对`throw`关键字使用的一些详细解释和示例。 ### 抛出异常的基本语法 在Java中，`throw`...
java 抛出异常处理的方法
08-29
throw 关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到 throw 语句时立即停止，它后面的语句都不执行。例如： ```java class MyException extends Exception { String message; public MyException...
Java学习资料-异常处理
06-15
当一个异常发生时，可以使用`throw`语句手动抛出一个异常对象，或者由Java虚拟机自动抛出。一旦异常被抛出，程序的正常执行流程就会被打断，然后控制权转交给异常处理代码。这个过程就是“捕获”异常，通常是通过`...
java中手动抛出异常-throw
aliven1的博客
02-18 3047
1.throw:手动抛出异常 2.throws:自动捕获手动抛出的异常 3.try-catch调用方法的位置捕获异常 4.e.getMessage获得异常的字符串 class Student { private int id; // 2.throws:自动捕获抛出的异常 public void regist(int id) throws Exception{ if(id>0){ this.id=id; }else{ // 1.throw:手动抛出异常 throw new E
Java 手动抛出异常 尚学堂127
BOKEhhh的博客
07-21 214
https://www.sxt.cn/Java_jQuery_in_action/six-custom-exception.html public class Test { public static void main(String[] args) throws IllegalAgeException { Person p = new Person(); p.setAge(-8); } } class Person { private int age; public
JAVA 手动抛出异常
qq_38244984的博客
11-27 1636
throw new NullPointerException();
java异常处理总结
weixin_34278190的博客
11-10 106
异常处理机制能让程序在异常发生时，按照代码的预先设定的异常处理逻辑，针对性地处理异常，让程序尽最大可能恢复正常并继续执行，且保持代码的清晰。Java中的异常可以是函数中的语句执行时引发的，也可以是程序员通过throw 语句手动抛出的，只要在Java程序中产生了异常，就会用一个对应类型的异常对象来封装异常，JRE就会试图寻找异常处理程序来处理异常。 Throwabl...
java手动抛出异常总结_Java 异常处理小结,从入门到精通
weixin_36047554的博客
02-24 202
内置异常和Throwable核心方法Java内置异常可查异常(必须要在方法里面捕获或者抛出)ClassNoFoundException 应⽤程序试图加载类，找不到对应的类IllegalAccessException 拒绝访问⼀个类的时候NoSuchFieldExcetion 请求的变量不存在NoSuchMethodException ⽅法不存在不可查异常ArrayIndexOutOfBoundsE...
Java手动抛出异常&python手动抛出异常
Haward
02-28 603
1. java if(条件){ throw new RuntimeException("描述。。。"); //直接手动抛出异常 } 2. python if 条件: raise RuntimeError('描述。。。') #直接手动抛出异常
Java手动抛异常
05-12 1391
public class A {          /**       * @param args       */       public static void main(String[] args) {           try{               throw new NullPointerExc
jmu-java-06异常-03-throw与throws
03-16
throw和throws是Java中处理异常的两个关键字。 throw用于在代码块中手动抛出一个异常对象，可以是Java内置的异常类，也可以是自定义的异常类。例如： ``` if (age < ) { throw new IllegalArgumentException("年龄不能为负数"); } ``` throws用于在方法声明中声明可能抛出的异常类型，以便调用该方法的代码能够正确处理异常。例如： ``` public void readFile(String fileName) throws FileNotFoundException { // ... } ``` 在调用readFile方法时，调用者需要使用try-catch语句块或者继续使用throws声明该方法可能抛出的异常类型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

雨翼轻尘

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

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

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

打赏作者

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

抵扣说明：

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

余额充值