精华内容
下载资源
问答
  • 使用throw抛出异常

    万次阅读 2018-04-14 17:48:45
    使用throw抛出异常throw总是出现在函数体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配...

    使用throw抛出异常

    throw总是出现在函数体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。

    我们知道,异常是异常类的实例对象,我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为:

    throw new exceptionname;
    
    

    例如抛出一个IOException类的异常对象:

    throw new IOException;
    
    

    要注意的是,throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的:

    throw new String(“exception”);
    
    

    这是因为String 不是Throwable 类的子类。

    如果抛出了检查异常,则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

    如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常。

    package Test; 
    import java.lang.Exception; 
    public class TestException { 
      static int quotient(int x, int y) throws MyException { // 定义方法抛出异常 
        if (y < 0) { // 判断参数是否小于0 
          throw new MyException("除数不能是负数"); // 异常信息 
        } 
        return x/y; // 返回值 
      } 
      public static void main(String args[]) { // 主方法 
        int a =3; 
        int b =0;  
        try { // try语句包含可能发生异常的语句 
          int result = quotient(a, b); // 调用方法quotient() 
        } catch (MyException e) { // 处理自定义异常 
          System.out.println(e.getMessage()); // 输出异常信息 
        } catch (ArithmeticException e) { // 处理ArithmeticException异常 
          System.out.println("除数不能为0"); // 输出提示信息 
        } catch (Exception e) { // 处理其他异常 
          System.out.println("程序发生了其他的异常"); // 输出提示信息 
        } 
      } 
      
    } 
    class MyException extends Exception { // 创建自定义异常类 
      String message; // 定义String类型变量 
      public MyException(String ErrorMessagr) { // 父类方法 
        message = ErrorMessagr; 
      } 
      
      public String getMessage() { // 覆盖getMessage()方法 
        return message; 
      } 
    }
    
    
    展开全文
  • C++使用throw抛出异常

    2021-01-22 15:04:07
    C++使用throw抛出异常

    C++使用throw抛出异常

    参考文章:

    (1)C++使用throw抛出异常

    (2)https://www.cnblogs.com/wujing-hubei/p/5440361.html


    备忘一下。


    展开全文
  • Java 使用 throw 抛出异常

    万次阅读 多人点赞 2019-06-11 21:13:47
    此外,Java 也允许程序自行抛出异常,自行抛出异常使用 throw 语句来完成。 本文包含: 抛出异常 自定义异常类 catch 和 throw 同时使用 Java 7 增强的throw 语句 异常链 1. 抛出异常 如果需要在程序中自行抛出...

    程序出现错误后,系统会自动抛出异常;此外,Java 也允许程序自行抛出异常,自行抛出异常使用 throw 语句来完成。
    本文包含:

    1. 抛出异常
    2. 自定义异常类
    3. catch 和 throw 同时使用
    4. Java 7 增强的throw 语句
    5. 异常链

    1. 抛出异常

    如果需要在程序中自行抛出异常,则应使用 throw 语句,throw 语句可以单独使用,throw 语句抛出的不是异常类,而是一个异常实例,而且每次只能抛出一个异常实例。throw 语法的语法格式如下:

    throw  ExceptionInstance; 
    

    可以使用 throw 语句实现如下代码:
    在这里插入图片描述
    下面程序中粗体字代码使用 throw 语句来自行抛出异常。当 Java 运行时接收到开发者自行抛出的异常时,会中止当前的执行流,跳到该异常对应的 catch 块来处理该异常。即不管是系统自动抛出的异常还是程序员手动抛出的异常,Java 运行时环境对异常的处理没有任何差异。

    如果 throw 语句抛出的异常是 Checked 异常,则该 throw 语句要么处于 try 块里,显式捕获该异常,要么放在一个带 throws 声明抛出的方法中,即把该异常交给该方法的调用者处理;
    如果 throw 语句抛出的异常是 Runtime 异常,则该语句无须放在 try 块里,也无须放在带 throws 声明抛出的方法中;程序既可以显式使用 try…catch来捕获并处理该异常,也可以完全不理会该异常,把该异常交给该方法调用者处理。
    例如下面例子:
    在这里插入图片描述
    通过上面程序可以看出,自行抛出Runtime 异常比自行抛出Checked 异常的灵活性更好。同样。抛出 Checked 异常则可以让编译器提醒程序员必须处理该异常。

    2. 自定义异常类

    在这里插入图片描述
    下面例子程序创建了一个自定义异常类:
    在这里插入图片描述
    在这里插入图片描述
    在大部分情况下,创建自定义异常都可采用与 AuctionException.java 相似的代码完成,只需改变 AuctionException 异常的类名即可,让该异常类的类名可以准确描述该异常。

    3. catch 和 throw 同时使用

    前面出现的异常处理方式有如下两种:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    4. Java 7 增强的throw 语句

    对于下面代码:
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述

    5. 异常链

    真实的企业级应用具有严格的分层关系,上层功能的实现严格依赖于下层的 API,也不会跨层访问。下图显示了这种具有分层结构应用的大致示意图:
    在这里插入图片描述
    对于采用上图结构的应用而言,当业务逻辑层访问持久层出现 SQLException 异常时,程序不会把底层的 SQLException 异常传到用户界面,有如下两个原因:

    1. 对于正常用户而言,他们不想看到底层 SQLException 异常,该异常对他们使用系统没有帮助。
    2. 对于恶意用户而言,将 SQLException 异常暴露出来不安全。

    通常的做法是:程序先捕获原始异常,然后抛出一个新的业务异常,新的业务异常中包含了对用户的提示信息,这种处理方式被称为异常转译。假设程序需要实现工资计算的方法,则程序应该采用如下结构的代码来实现该方法:
    在这里插入图片描述在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述在这里插入图片描述
    创建了这个 SalException 业务异常类后,就可以用它来封装原始异常,从而实现对异常的链式处理。

    展开全文
  • 4-使用throw抛出异常 1.抛出异常 (1)如果需要在程序中自行抛出异常,则应该使用throw语句,throw语句可以单独使用,throw语句抛出的不是异常类,而是一个异常实例,而且每次只能抛出一个异常实例; (2)throw...

    4-使用throw抛出异常

    1.抛出异常

    (1)如果需要在程序中自行抛出异常,则应该使用throw语句,throw语句可以单独使用,throw语句抛出的不是异常类,而是一个异常实例,而且每次只能抛出一个异常实例;

    (2)throw语句如果抛出的异常是Checked异常,则该throw语句要么处于try块中,显式捕获该异常,要么放在一个带throws声明抛出的方法中,即把该异常交给方法的调用者处理;如果throw语句抛出的异常是Runtime异常,则该语句无须放在try块里,也无须放在throws声明的方法中;程序可以显式使用try..catch来捕获并处理该异常,也可以完全不理会异常,把异常交给调用者处理;

    public class Test7 {
        public static void main(String[] args) {
            try{
                //调用声明抛出Checked异常的方法,要么显式捕获该异常
                //要么在main方法中再次声明抛出
                throwChecked(-3);
            }catch(Exception e){
                System.out.println(e.getMessage());
            }
            //调用声明抛出Runtime异常的方法既可以显式捕获该异常
            //也可以不理会该异常
            throwRuntime(3);
        }
        public static void throwChecked(int a) throws Exception{
            if(a>0){
                //自行抛出Exception异常
                //该代码必须处于try...catch块中,或处于带throws声明的方法中
                throw new Exception("a的值大于0,不符合要求");
            }
        }
        public static void throwRuntime(int a){
            if(a>0){
                //自行抛出RuntimeException异常,既可以显式捕获该异常
                //也可完全不理会该异常,把该异常交给该方法的调用者处理
                throw new RuntimeException("a的值大于0,不符合要求");
            }
        }
    }

     

    2.自定义异常类

    (1)用户自定义异常都应该继承Exception基类,如果希望自定义Runtime异常,则应该继承RuntimeException异常基类。

    (2)定义异常类时通常需要提供两个构造器,一个无参构造器,一个带有字符串参数的构造器,这个字符串将作为该异常对象的描述信息,即getMessage()方法的返回值;

    public class MyException extends Exception{
        //无参数构造器
        public MyException(){
            
        }
        //带一个字符串参数的构造器
        public MyException(String msg){
            super(msg);
        }
    }

     

    3.catch和throw同时使用

    (1)多个方法协同处理同一个异常的情形,可以在catch块中结合throw语句来完成:

    public class AuctionTest {
        private double initPrice = 30.0;
        //因为该方法中显式抛出了AuctionException异常
        //所以此处需要声明抛出AuctionException异常
        public void bid(String bidPrice)throws MyException{
            double d = 0.0;
            try{
                d = Double.parseDouble(bidPrice);
            }catch(Exception e){
                //此处完成本方法中可以对异常执行的修复处理
                //此处仅仅是在控制台打印异常的跟踪栈信息
                e.printStackTrace();
                //再次抛出自定义异常
                throw new MyException("竞拍价格必须是数值,不能包含其他字符");
            }
            if(initPrice > d){
                throw new MyException("竞拍价比起拍价低,不允许竞拍");
            }
            initPrice = d;
        }
        public static void main(String[] args) {
            AuctionTest at = new AuctionTest();
            try{
                at.bid("df");
            }catch(MyException e){
                //再次捕获到bid()方法中的异常,并对该异常进行处理
                System.out.println(e.getMessage());
            }
        }
    }

     

    4.throw语句增强

      有如下代码:

      try{

        new FileInputStream("a.txt");

      }catch(Exception e){

        e.printStackTrace();

        throw e;  //再次抛出捕获到的异常

      }

      Java7以前,因为捕获到异常时声明的异常类型为Exception,所以在再次抛出异常时抛出的异常同样为Exception异常:

      public staic void main(String args[])

        throws Exception  //Java6认为可能抛出Exception异常

      {

        try{

          new FileInputStream("a.txt");

        }catch(Exception e){  //声明捕获到的异常为Exception异常

          e.printStackTrace();

          throw e;  //声明捕获的异常是Exception 再次抛出的异常同样为Exception

        }

      }

      从java7开始,编译器会自行检查throw语句抛出异常的实际类型:

      public staic void main(String args[])

        throws FileNotFoundException  //Java7编译器检查后,只需抛出FileNotFoundException异常

      {

        try{

          new FileInputStream("a.txt");

        }catch(Exception e){  //声明捕获到的异常为Exception异常

          e.printStackTrace();

          throw e;//声明捕获的异常是Exception 编译器检查后实际上的异常为FileNotFoundException异常

        }

      }

     

    5.异常链

    (1)把底层原始异常直接传给用户是一种不好的表现,通常做法为:程序先捕获原始异常,然后抛出一个新的业务异常,新的业务异常包含对用户的提示信息,这种处理方式被称为异常转译;

    (2)把原始异常隐藏起来,仅仅向上提供必要的提示信息的处理方式,可以保证底层异常不会扩散到表现层。

    转载于:https://www.cnblogs.com/ljiwej/p/7275866.html

    展开全文
  • 二十一天学通C++之使用throw抛出异常
  • c++ 使用throw抛出异常

    千次阅读 2017-09-16 16:01:59
    抛出异常(也称为抛弃异常)即检测是否产生异常,在C++中,其采用throw语句来实现,如果检测到产生异常,则抛出异常。该语句的格式为: throw 表达式; 如果在try语句块的程序段中(包括在其中调用的函数)发现了...
  • 一、Throw和throws区别:1、书写:throws定义在方法名上,throw定义在方法体内2、作用:throws声明异常,throw抛出异常3、语法:throws 异常类 throw 异常对象4、Throws 异常类1,.....,异常n throw 异常对象二、用...
  • 使用throw抛出异常 c++

    2016-02-23 22:32:13
    抛出异常(也称, 抛弃异常)即检测程序产生异常时的处理。在C++中,采用throw语句来实现,即若检测到产生异常,则抛出异常。 该语句的格式为:  throw 表达式;
  • 1.为什么要使用throw主动抛出异常对象 根据已有内容可知,在程序中应该尽量避免异常,程序中出现了异常我们要进行抛出和捕获,这是一件很麻烦的事情。 但throw的作用是主动抛出异常对象:这是自己给自己找麻烦? ...
  • 手动使用throw抛出异常

    千次阅读 2018-05-07 22:44:08
    //异常,创建异常对象 throw new Illegalnameexception("用户名长度不能少于6位"); } //如果代码能执行到此处,证明用户名是合法的 System.out.println("注册成功"); } } /* 自定义"无效...
  • 2. 使用throw抛出异常: 当程序出现错误时,系统会自动抛出异常;除此之外,Java也允许程序自行抛出异常,自行抛出异常使用throw语句来完成。 2.1 抛出异常: 很多时候,系统是否要抛出异常,可能需要根据...
  • 1,抛出异常 2,自定义异常类 3,catch 和 throw 同时使用 4,Java 7 增强的 throw 语句 5,异常链
  • Java编程中使用throw关键字抛出异常的用法简介throw抛出异常的方式比较直接:if(age < 0){throw new MyException("年龄不能为负数!");}来看一个例子:package Test;public class Test2 {public static void main...
  • throw抛出异常

    千次阅读 2017-04-12 09:50:58
    throw抛出异常介绍 如果需要在程序中自行抛出异常,应使用throw语句,throw语句可以单独使用,throw语句抛出的不是异常类,而是一个异常实例,而且每次只能抛出一个异常实例。 throw语句的语法格式如下: ...
  • 转载:Java:详解Java中的异常(Error与Exception) Java 使用 throw 抛出异常 本篇文章做笔记用,侵权删。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,268
精华内容 907
关键字:

使用throw抛出异常