精华内容
下载资源
问答
  • 怎么手动抛出异常
    千次阅读
    2021-03-05 16:38:58

    一、手动抛出异常 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");

    二、抛出异常

    1、实现步骤

    (1)创建一个异常对象。封装一些提示信息(信息可以自己编写)

    (2)需要将这个异常对象告诉给调用者。通过关键字throw 就可以完成。throw 异常对象。

    throw 关键字作用:用在方法内,用来抛出一个异常对象,将这个异常对象传递到调用者处,并结束当前方法的执行。

    使用格式:

    throw new 异常类名("异常产生的原因");

    注意:

    (1)throw 关键字必须写在方法的内部

    (2)throw 关键字后边 new 的对象必须是 Exception或者Exception的子类对象

    (3)throw 关键字抛出指定的异常对象,我们就必须处理这个异常对象

    throw 关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)

    throw 关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch

    2、throw 与 throws 区别

    面试题:throw 与 throws 有什么区别?

    (1)throw 用于手动抛出异常对象,是个可执行的语句

    (2)throws:在方法签名中,声明方法可能抛出什么异常,让调用者来处理这些异常。

    3、代码示例

    1 //主方法

    2 public static voidmain(String[] args) {3 //int[] arr = null;

    4 int[] arr = new int[3];5 int e = getElement(arr,3);6System.out.println(e);7}8 //定义一个方法,获取数组指定索引处的元素

    9 public static int getElement(int[] arr,intindex){10 /*11 我们可以对传递过来的参数数组,进行合法性校验

    12 如果数组arr的值是null

    13 那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"

    14*/

    15 if(arr == null){16 throw new NullPointerException("传递的数组的值是null");17}18

    19 /*20 我们可以对传递过来的参数index进行合法性校验

    21 如果index的范围不在数组的索引范围内

    22 那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"

    23*/

    24 if(index<0 || index>arr.length-1){25 /*26         判断条件如果满足,当执行完throw抛出异常对象后,方法已经无法继续运算。

    27         这时就会结束当前方法的执行,并将异常告知给调用者。这时就需要通过异常来解决。

    28*/

    29 throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");30}31

    32 int ele =arr[index];33 returnele;34}35

    注意:NullPointerException、ArrayIndexOutOfBoundsException 是一个运行期异常,我们不用处理,默认交给JVM处理。

    Tips:如果产生了问题,我们就会throw将问题描述类即异常进行抛出,也就是将问题返回给该方法的调用者。 对于调用者,有两种解决方式:一种是进行捕获处理,另一种就是继续将异常声明出去,使用 throws 声明处理。

    4、扩展:Objects 非空判断

    Objects 是由一些静态的使用方法组成,这些方法是 null-save(空指针安全的)或 null-tolerant(容忍空指针的),那么在它的源码中,对对象的null 值进行了抛出异常操作。

    public static T requireNonNull(T obj) :查看指定引用对象不是null。

    源码:

    public static T requireNonNull(T obj) {

    if (obj == null)

    throw new NullPointerException();

    return obj;

    }

    这样,当我们需要对传递过来的参数进行合法判断,判断是否为 null的时候,可以直接使用 该方法即可。

    Demo:

    1 public static void method(Object obj){

    2 //对传递过来的参数进行合法性判断,判断是否为null

    3 /*if(obj == null){

    4 throw new NullPointerException("传递的对象的值是null");

    5 }*/

    6

    7 //Objects.requireNonNull(obj);

    8 Objects.requireNonNull(obj,"传递的对象的值是null"); // 方法重载

    9 }

    更多相关内容
  • 手动抛出异常

    千次阅读 2019-07-31 21:53:49
    1.在程序中,可能会遇到JDK提供的任何标准异常类都无法充分描述清楚我们想要表达的问题,这种情况下...自定义异常类如果继承CheckedException类,则为受检查异常,必须对其进行处理(使用Try-Catch-Finally或Throws...

          1.在程序中,可能会遇到JDK提供的任何标准异常类都无法充分描述清楚我们想要表达的问题,这种情况下可以创建自己的异常类,即自定义异常类。

          2.自定义异常类只需从Exception类或者它的子类派生一个子类即可。

          3.自定义异常类如果继承CheckedException类,则为受检查异常,必须对其进行处理(使用Try-Catch-Finally或Throws抛出),否则编译不会通过,编译器会报错;如果不想处理,可以让自定义异常类继承运行时异常RuntimeException类。

          4.习惯上,自定义异常类应该包含2个构造器:一个是默认的构造器,另一个是带有详细信息的构造器。

    /**IllegalAgeException:非法年龄异常,继承Exception类*/
    class IllegalAgeException extends Exception {
        //默认构造器
        public IllegalAgeException() {
         
        }
        //带有详细信息的构造器,信息存储在message中
        public IllegalAgeException(String message) {
            super(message);
        }
    }

     

    代码实例:

    public class Test{
        public static void main(String[] args){
            Person p = new Person();
            p.getAge(-18);
        }
    }
    class Person{
        private int age;
        public int getAge(){
            return age;
    }
        public int setAge(int age){
            if(age<0){
                throw new IllegalAgeException("年龄不能为负数"); //注意:此处throw为手动抛出异常
            }
            this.age = age;
        }
    }
    /**IllegalAgeException:非法年龄异常,继承RuntimeException类*/
    //自定义异常类应包含两个构造器,一个默认构造器,还有一个带详细信息的构造器
    public IllegalAgeEcxeption extends RuntimeException{
        public IllegalAgeException(){
    }
        public IllegalAgeException(String message){
            super(message);
        }
    }

     

    public class Test {
        public static void main(String[] args) {
            Person p = new Person();
            p.setAge(-10);
            p.getAge();
        }
    }
    class Person{
        private int age;
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            if (age<0){
                try {
                    throw new IllegalAgeException("人的年龄不能为负数");
                } catch (IllegalAgeException e) {
                    e.printStackTrace();
                }
            }
            this.age = age;
        }
    }
    /**IllegalAgeException:非法年龄异常,继承RuntimeException类*/
    class IllegalAgeException extends Exception{
        //默认构造器
        public IllegalAgeException(){
        }
        //带有详细信息的构造器,信息存储在message中
    public IllegalAgeException(String message){
        super(message);
    }
    }
    public class Test {
        public static void main(String[] args) throws IllegalAgeException {
            Person p = new Person();
            p.setAge(-10);
            p.getAge();
        }
    }
    class Person{
        private int age;
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) throws IllegalAgeException {
            if (age<0){
                throw new IllegalAgeException("人的年龄不能为负数");
            }
            this.age = age;
        }
    }
    /**IllegalAgeException:非法年龄异常,继承RuntimeException类*/
    class IllegalAgeException extends Exception{
        //默认构造器
        public IllegalAgeException(){
        }
        //带有详细信息的构造器,信息存储在message中
    public IllegalAgeException(String message){
        super(message);
    }
    }

     

     如果改为Exception,则为CheckedException类,必须加Try-Catch-Finally或Throws抛出,否则编译不会通过,编译器会报错。

    使用异常机制的建议

          1.要避免使用异常处理代替错误处理,这样会降低程序的清晰性,并且效率低下。

          2.处理异常不可以代替简单测试---只在异常情况下使用异常机制。

          3.不要进行小粒度的异常处理---应该将整个任务包装在一个try语句块中。

          4.异常往往在高层处理

        欢迎批评指正

     

     

    展开全文
  • Java-手动抛出异常

    千次阅读 2022-04-26 10:37:46
    Java-手动抛出异常 1.概念 关于异常对象的产生 系统自动生成的异常对象 手动生成一个异常对象,并抛出(throw) 2.code举例 package p8exception.p9; public class StudentTest { public static void main...

    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);
                System.out.println(s);
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
    
    
        }
    }
    
    
    class Student {
        private  int id;
    
        public void regist(int id) throws Exception {
            if(id > 0) {
                this.id = id;
            }else {
    //            System.out.println("非法");
    //            throw new RuntimeException("输入非法");
                throw new Exception("输入非法");
            }
    
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "id=" + id +
                    '}';
        }
    }
    
    展开全文
  • java中手动抛出异常-throw

    千次阅读 2022-02-18 15:27:58
    1.throw:手动抛出异常 2.throws:自动捕获手动抛出的异常 3.try-catch调用方法的位置捕获异常 4.e.getMessage获得异常的字符串 class Student { private int id; // 2.throws:自动捕获抛出的异常 public void ...

    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 Exception("您输入的数据非法!");
    		}
    	}
    }```
    
    @Test
    	public void testStudent(){
    		Student s=new Student();
    //		3.try-catch调用方法的位置捕获异常
    		try {
    			s.regist(-1114);
    		} catch (Exception e) {
    //			4.getMessage获得异常的字符串
    			System.out.println(e.getMessage());
    			e.printStackTrace();
    		}
    	}
    
    
    
    
    展开全文
  • python手动抛出异常

    千次阅读 2020-11-14 15:09:13
    手动抛出异常的格式 try:.... except: print(“错误原因”) 这里我们以pymysql模块为例 import pymysql #创建数据库连接 try: host="localhost" db="qu" user="root" passwd="123456" cheaset="utf8" ...
  • 在android开发过程中,我们经常遇到异常的问题,崩溃抛出异常的时候,是非常令人烦闷的。但是异常有一个好处,使得app能在编译的时候给我们提供一些bug信息,有时可能比较模糊,有时可能很精准,甚至提示报错行。...
  • (不能捕获自定义抛出异常,否则无法开启事务回滚) * @param importFile * @return * @throws Exception */ @Transactional(rollbackFor=Exception.class) //必须加上括号内的属性,否则事务无.
  • 手动抛出异常 关于异常对象的产生: 系统自动生成的异常对象 手动的生成一个异常对象,并且抛出(throw) throw手动抛出异常 eg: class Student{ private int id; public void regist(int id){ if(id>0){ this....
  • C#手动抛出异常

    2021-08-31 10:51:33
    代码 throw new IndexOutOfRangeException("异常提示信息");
  • 发生异常时,程序会突然终止,并且生成异常的行之后的代码将永远不会执行。示例importjava.util.Scanner;publicclassExceptionExample{publicstaticvoidmain(Stringargs[]){Scannersc=newScanner(System.in);System....
  • 今天学习下手动抛出异常,有人可能奇怪写程序就为了正常运行,为何还要手动抛出异常呢?这要在实际项目中根据业务需求来,如果程序本身运行是没问题的,但是某个环节不符合业务需求(比如账户的存款额不够给员工发...
  • js手动抛出异常

    2021-04-27 14:34:06
    js手动抛出异常
  • laravel 手动抛出异常

    2021-03-18 15:59:12
    if($category->user_id != auth()->id()){ throw new ModelNotFoundException(); }
  • 我们通常在项目中都是使用全局事务配置,这样我们就不必在每个业务类的方法上加 @Transactional 注解,只要代码抛出异常,就会自动回滚事务 但是我们有的时候需要事务回滚并不一定是代码发生了异常,而是我们对业务...
  • 手动抛出异常对象

    2019-08-07 13:10:27
    程序在正常执行过程中,一旦出现异常,就会在异常代码处生成一个对应异常类的对象,并将此对象抛出,一旦抛出该对象以后,其后...注意: 手动抛异常可以抛Exception及其子类,但一般是抛Exception,RuntimeExceptio...
  • 我们常说执行程序时发生了异常,那么什么是异常。异常是在python解释器在...除了python已经有了的异常,根据实际需要,我们也可以自定义异常,但是需要我们手动抛出异常。如果想要对异常进行处理,就要使用try/except。
  • 手动抛出异常:throw(注意throws是处理异常,throw是抛出异常) 1,Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出,也可根据需要使用人工创建并抛出。 2首先要生成异常类对象,然后通过throw...
  • 在日常的开发中,我们往往会使用到手动抛出异常,这里就需要用到thorw关键字 代码示例: /** * @ Author: Zhangyu * @ Date: 2020/7/27 * @ Description: */ public class Test { public static void main...
  • SUN提供的JDK内置的异常是肯定不够用的。在实际开发中,又很多业务,这些业务出现异常之后,JDK中都是没有的,和业务挂钩的。那么异常类我们程序员可以定义吗? 异常是可以自定义的 1、自定义异常的方法 需要两步:...
  • 我们常用的事务通常会用Spring自带的注解 @Transactional ,将所有事务交给Spring来控制,注解默认是抛出异常进行事务回滚,但是有很多时候我们的事务需要手动抛出异常,这时候我们不能直接 throw new Exception();...
  • 注:关于第4点,异常层层外,由调用者进行处理。
  • 手动的生成一个异常对象,并抛出(throw) 过程二:“抓”: 可以理解为异常的处理方式:① try-catch-finally ② throws + 异常类型 2.异常处理方式一:try-catch-finally 2.1 使用说明: *
  • 有时候会遇到需要手动抛出异常来回滚事务的情况,一般抛出异常后显示的是500服务器错误,如果想要返回json数据给前端的话,就可以用自定义异常类+全局异常捕捉。 二、自定义异常类 这里只定义了code码和msg消息...
  • 手动抛出异常、自定义异常的用法

    千次阅读 2018-11-24 20:49:58
    手动抛出异常thorw new Exception(String);(匿名对象调用Exception方法) String的内容用public String getMessage()方法调用输出 private int age; private String gender; private Stri...
  • java中手动抛出异常

    2020-06-25 18:55:43
    java中手动抛出异常 java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出,也可根据需要使用人工创建并抛出 。 首先要生成异常类对象,然后通过throw语句实现抛出操作(提交给Java运行环境)。 ...
  • 计算机后端-Java-Java核心基础-第17章 异常处理 16. 手动抛出异常对象.avi
  • java 手动抛出异常

    万次阅读 2017-11-20 16:33:49
    当然需要先用try catch捕获,但注意new Exception("")括号里的字符串其实是异常原因,所以获取是要用ex.getCause().getMessage() public void divide() throws Exception { int dylist = dyDao.findByHql("from ...
  • 1. java if(条件){ throw new RuntimeException("描述。。。"); //直接手动抛出异常 } 2. python if 条件: raise RuntimeError('描述。。。') #直接手动抛出异常

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 149,603
精华内容 59,841
关键字:

怎么手动抛出异常