精华内容
下载资源
问答
  • 主要给大家介绍了关于C++中try throw catch异常处理的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者使用C++具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • try catch 和throw以及throws的使用

    千次阅读 2019-04-13 17:08:25
    try-catch和throw,throws的区别 java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的...

    转载:https://www.cnblogs.com/zhangdaicong/p/6127984.html

    try-catch和throw,throws的区别

    java里的异常多种多样,这是一种非常有用的机制,它能帮助我们处理那些我们未知的错误,在java里,关于异常的有throw throws,还有一个try catch 程序块。接下来我们挨个看看这几个的作用。

    1.throw

    throw 就是抛出一个异常,并获取这个异常的引用,这个异常会被抛到外部的环境,由外部环境进行处理

    class A{
        public void func() throws Exception{
            throw new Exception();
        }
    }

    这里抛出了一个Exception,Exception是throwable的子类,是所有异常的基类。与此同时,throwable还有另一个子类,也就是Error。

    这里会把Exception这个引用抛到外部环境中去处理。

    throw跟try...catch...finally的对比:

     

    public class  ZeroTest {

        public static  void  main(String[] args) {

         try{

           int i = 1000;

           System.out.print(i);

      }catch(Exception e){

           System.out.print(1);

           throw new  RuntimeException();

      }finally{

           System.out.print(2);

      }

          System.out.print(3);

      }

    }

     

      try catch是直接处理,处理完成之后程序继续往下执行,throw则是将异常抛给它的上一级处理,程序便不往下执行了。

    本题的catch语句块里面,打印完1之后,又抛出了一个RuntimeException,程序并没有处理它,而是直接抛出,

    因此执行完finally语句块之后,程序终止了

     

       首先执行try,遇到算术异常,抛出,执行catch,打印1,然后抛出RuntimeException,缓存异常,执行finally,打印2,然后抛出RuntimeException。

      如果catch中没有抛出RuntimeException,则执行结果为123。

     

    2.throws

    那我们就不得不说一下throws,其实throws并不是抛出一个实际的Exception而是一个异常声明,它声明这个方法可能会抛出一个异常,注意是可能,所以在没有异常的情况下也是可以用throws的,而throws本身的作用也是用来提高程序的健壮性,反过来,如果这个方法的的确确的有一个异常,那么编译器会强制让你加上throws这个异常声明。

    通常throws是写在参数列表的后面,这样就表明这个方法有可能会抛出一个异常

    class A{
        public void func() throws Exception{
            throw new Exception();
        }
        
        public void g() throws Exception{
            
        }
    }

    3.try...catch

    当我们在其环境中调用func 和 g的时候,编译器会通知我们需要用一个Try catch程序块来处理这个异常。

    这个程序块分两块,第一块是try{} ,第二块是catch(exception的引用){}
    try这个程序块很有意思,因为它的名字很易懂,就是尝试,尝试能不能正常的走完整个作用域,如果不能则抛出一个异常。所以我们在try块里经常放上可能会抛出异常的程序段。
    而catch恰好就是处理try里抛出来的异常,其中catch的参数列表接收的是一个异常的引用,是throw抛出来的异常的引用,这样我们就可以得到这个异常的对象,倒不如说我们是得到来了这个异常对象的引用,因为在java里,通常我们也只能通过引用来操纵对象。

    PS:当 throw new RuntimeException的时候,不用throws

    public class Main {
        public static void main(String[] args){
            A a = new A();
            try{
                a.func();
                a.g();
            }
            catch(Exception e){
                System.out.println("捕获了一个异常");
            }
        }
    }

    我们捕获了func 的异常,因为我们明确的指明func 会抛出一个异常throw new Exception();所以我们这里也会捕获到,并去处理它,所以运行起来我们会看到控制台上会打印“捕获了一个异常”。

    尽管g()没有抛出任何的异常,编译器还是要求我们要用try catch把它括起来,是因为它拥有一个throws 异常说明。

     

     

    **下面是常见的几种异常,供大家参考:

    输入输出异常:IOException
    算术异常类:ArithmeticExecption
    空指针异常类:NullPointerException
    类型强制转换异常:ClassCastException

    操作数据库异常:SQLException

    文件未找到异常:FileNotFoundException
    数组负下标异常:NegativeArrayException
    数组下标越界异常:ArrayIndexOutOfBoundsException
    违背安全原则异常:SecturityException
    文件已结束异常:EOFException
    字符串转换为数字异常:NumberFormatException
    方法未找到异常:NoSuchMethodException

     

    转载:https://www.cnblogs.com/zhao307/p/5560344.html

    1:先写个简单的类:

    复制代码

    package com.exception.demo;
    
    public class Main {
        public static void main(String[] args) {
            Main main = new Main();
        }
    
        public void methodTry() {
    
        }
    
        public void methodThrow() {
    
        }
    }

    复制代码

    初始环境就是这么简答。

    2:下面给方法methodTry加上方法主体:

    复制代码

        public static void main(String[] args) {
            Main main = new Main();
            main.methodTry();
        }
    
        public void methodTry() {
            int a=10;
            int b=0;
            int c=a/b;
        }

    复制代码

    刚开始学代码的时候都会写这个方法,会抛出一个异常:

      

    控制台很清楚的告诉我们,被除数不能为0.但是如果我们想自己获取这个异常,然后做些操作呢?比如说 如果这个方法体有问题,我就做一个输出。

    复制代码

        public void methodTry() {
            try {
                int a=10;
                int b=0;
                int c=a/b;
                System.out.println(c);
            } catch (Exception e) {
                System.out.println("这个方法体有问题:"+e.getMessage());
            }
            
        }

    复制代码

    这个时候就用到了try-catch,手动的捕获这个异常,然后进行我们需要的操作。毕竟异常分很多种,并不是所有的异常都是我们不需要的。比如说对用户登录来说,登录成功 登录失败两种结果,登录失败又分为重复登录,账号密码不匹配等。我们可以把这些失败全都写成Exception。当成功的时候就直接返回,失败的时候抛出异常,这个可比我们写好多返回值简单多了。

    接着说try-catch

      

    我们手动的捕获了这个异常。上面的代码告诉我们,当try-catch块中有异常时,异常后面的代码是不会执行的。try-catch还有什么好处?回滚。

    3:throw

    复制代码

        public static void main(String[] args) {
            Main main = new Main();
            main.methodThrow();
        }
    
    
    
        public void methodThrow() {
            throw new Exception("这里有异常");
        }

    复制代码

    其实当我简单的抛出个异常的时候,throw new Exception()这里会报错,现在看一个报错信息:

      

    显示让我们选择是throws 还是try-catch。

    我们写好的throw是什么意思呢? 其实跟a/0是一个意思,都是抛出一个异常,只不过一个是jdk已经定义好的异常,被除数不能为0.一个是我们手动抛出的异常。

    先用try-catch试试看

      

    复制代码

        public void methodThrow() {
            try {
                throw new Exception("这里有异常");
            } catch (Exception e) {
                System.out.println("MethodThrow:"+e.getMessage());
            }
        }

    复制代码

      

    重点在于手动抛出异常后,我们要在catch中进行处理,在catch中写我们的部门逻辑代码。

    4:throws

    刚才我们选择的是try-catch,现在选择throws

    复制代码

        public static void main(String[] args) throws Exception {
            Main main = new Main();
            main.methodThrow();
        }
    
        public void methodThrow() throws Exception {
            throw new Exception("这里有异常");
        }

    复制代码

    方法methodThrow throws Exception之后,他的父类就面临着两种情况,要么try-catch 要么throws这个异常。这种情况跟methodThrow中手动抛出异常遇到的问题是一样的。

    看来可以这么理解:

      throw是手动抛出异常,跟 被除数不能为0 数组下标越界等异常一样,都是异常。

      try-catch是在catch中手动捕获异常,然后进行一些操作。比如说输出异常信息,打印错误日志等。

      throws是往上级抛出异常,我的方法methodThrow有异常,但是在这个方法中我不进行处理了,让上级进行处理吧。然后就跑到main函数那去了。对main函数来说,可以throws让系统进行处理,也可以自己处理这个异常啊。main.methodThrow()和a/0 、throw new Execption()没什么区别,都是有异常。

    其实可以整体的写:

    复制代码

        public static void main(String[] args){
            Main main = new Main();
            try {
                main.methodThrow();
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
        }
    
        public void methodThrow() throws Exception {
            throw new Exception("这里有异常");
        }

    复制代码

    方法中的异常,到main函数中再进行处理。

     

     

    总结:在程序中有异常的代码被try catch后,后边的代码能够继续执行,如果是throws 出来的,则运行到异常代码处就会停止执行,抛出异常

    展开全文
  • 异常处理(throwtry, catch)

    千次阅读 2018-07-29 17:54:44
    异常处理的意思是说当次模块产生错误时,此模块并不处理,... throw 表达式 -- 捕获并处理异常的程序段  try  复合语句 (保护段)  catch(异常声明)  复合语句 (异常处理程序)  catch(异常声...

    异常处理的意思是说当次模块产生错误时,此模块并不处理,而是抛给此模块的调用者来处理

    异常处理的语法:

    -- 抛掷异常的程序段: 

        throw 表达式

    -- 捕获并处理异常的程序段

        try

           复合语句          (保护段)

        catch(异常声明)

            复合语句            (异常处理程序)

        catch(异常声明)

            复合语句

    ** 若有异常则通过throw创建一个异常对象并抛掷

    ** 将可能抛出异常的程序段嵌在try块之中,通过正常的顺序执行到达try语句,然后执行try块内的保护段

    ** 如果在保护段执行期间没有引起异常,那么跟在try块后的catch子句就不执行。程序从try块后的最后一个catch子句后面的语句继续执行

    ** catch子句按其在try块后出现的顺序被检查,匹配的catch子句将捕获并处理异常(或继续抛掷异常)

    ** 如果匹配的处理器未找到,则库函数terminate将被自动调用,其缺默认能是调用abort终止程序 

    例子:

    #include <iostream>
    
    using namespace std;
    
    int divide(int x, int y){
    	if (y ==0 ){
    		throw x;
    	}
    	return x/y;
    }
    int main(){
    	try{
    		cout << "5/2 = " << divide(5, 2)<< endl;
    		cout << "8/0 = " << divide(8, 0)<< endl;
    		cout << "7/1 = " << divide(7, 1)<< endl;
    	} catch (int e){
    		cout << e << " is divided by zero! " <<endl;
    	}
    	cout<< "That is ok." <<endl;
    	return 0;
    }

    运行结果:

    异常接口声明:

    -- 一个函数显示声明可能抛出的异常,有利于函数的调用者为异常处理做好准备

    ** 可以在函数的声明中列出这个函数可能抛掷的所有异常类型

        例如:void fun() throw(A, B, C, D);

    ** 若无异常接口声明,则此函数可以抛掷任何类型的异常

    ** 不抛掷任何类型异常的函数声明如下:

            void fun() throw();

    异常处理中的构造与析构:

    自动的析构:

    -- 找到一个匹配的catch异常处理后

        * 初始化异常参数

        * 将从对应的try块开始到异常被抛掷处之间构造(且尚未析构)的所有自动对象进行析构

        * 从最后一个catch处理之后开始恢复执行

    例子:

    #include <iostream>
    #include <string>
    
    using namespace std;
    
    class MyException{
    public:
    	MyException(const string &message) : message(message) {}
    	~MyException() {}
    	const string &getMessage() const { return message;}
    private:
    	string message;
    };
    
    class Demo{
    public:
    	Demo(){cout << "Constructor of Demo" << endl;}
    	~Demo() {cout << "Destructor of Demo" << endl;}
    };
    
    void func() throw(MyException) {
    	Demo d;
    	cout << "Throw MyException in func()" <<endl;
    	throw MyException("exception thrown by func()");
    }
    
    int main(){
    	cout << "In main function" <<endl;
    	try{
    		func();
    	}
    	catch(MyException & e){
    		cout <<" Caught an exception: " << e.getMessage() <<endl;
    	}
    
    	cout << "Resume the execution of main()" <<endl;
    	return 0;
    }

    运行结果:

    从运行结果中可以看出,当异常抛出的时候,创建的对象会自动析构掉

    标准程序库异常处理:

    标准异常类的基础:

    exception:标准程序库异常类的公共基类

    logic_error:表示可以在程序中被预先检测到的异常

        * 如果小心地编写程序,这类异常能够避免

    runtime_error表示难以被预先检测的异常

    例子:

    #include <iostream>
    #include <cmath>
    #include <stdexcept>
    
    using namespace std;
    
    double area(double a, double b, double c) throw(invalid_argument)
    {
    	if(a <= 0 || b <= 0 || c<= 0)
    		throw invalid_argument(" the side length should be postive");
    	if(a+b <= c || b+c <= a || c+a <= b)
    		throw invalid_argument (" the side length should fit yje triangle inequation");
    
    	double s = (a+b+c)/2;
    	return sqrt(s*(s-a)*(s-b)*(s-c));
    }
    
    int main(){
    	double a, b, c;
    	cout << "Please input the side lengths of a triangle: ";
    	cin >> a >> b >>c;
    	try {
    		double s = area(a, b, c);
    		cout<< "Area: "<< s <<endl;
    	} catch (exception &e){
    		cout << "Error: " << e.what() <<endl;
    	}
    	return 0;
    }

    运行结果:

     

     

    展开全文
  • try 尝试执行 catch 捕获异常 throw 抛出异常 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA_Compatible" content="IE=edge"> ...
    try尝试执行
    catch捕获异常
    throw抛出异常
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA_Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>Title</title>
        <link rel="stylesheet" href="bootstrap-3.3.7-dist/css/bootstrap.min.css" rel="stylesheet">
    </head>
    <body>
    <!--在下面的input中输入一个数字-->
    <input type="text" id="numble">
    <button type="button" id="test">测试输入</button>
    <script type="text/javascript">
        var button = document.getElementById('test');
        button.onclick = function () {
            try{
            var numble = document.getElementById('number').value;//获取在input中输入的数字,但是一不小心写错了numble写成了number。
            }
            catch (e) {
                // catch的参数e就是这个错误
                
                console.log(e);//输出如下:
                // TypeError: Cannot read property 'value' of null
                //     at HTMLButtonElement.button.onclick (a_58_try_catch_throw_的用法_.html?_ijt=uq62hvdk6fjgh3f20vkmjb458s:18)
                
                
                // 可是希望能够输出input中的value,在上面代码不改变的情况下,可以:
                var numble_2 = document.getElementById('numble').value;
                console.log(numble_2);//输出:
                // TypeError: Cannot read property 'value' of null
                //     at HTMLButtonElement.button.onclick (a_58_try_catch_throw_的用法_.html?_ijt=fmrk8e01rf9e9a3m4nrpmh97di:18)
                // 1234
            }
        };
    </script>
    </body>
    </html>
    

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta http-equiv="X-UA_Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width, initial-scale=1">
        <title>Title</title>
        <link rel="stylesheet" href="bootstrap-3.3.7-dist/css/bootstrap.min.css" rel="stylesheet">
    </head>
    <body>
    <!--在下面的input中输入一个数字-->
    <input type="text" id="numble">
    <button type="button" id="test">测试输入</button>
    <script type="text/javascript">
        var button = document.getElementById('test');
        button.onclick = function () {
            try{
                var numble = document.getElementById('numble').value;
                if (numble != 0) {
                    throw "value不为0"
                }
            }
            catch (e) {
                // catch的参数e就是这个错误
    
                console.log(e);//输出如下:
                // value不为0
            }
        };
    </script>
    </body>
    </html>
    
    展开全文
  • try/catch/throw

    2021-01-20 13:31:41
    try/catch/throw try/catch/throw的优点: 1.可以自定义抛出异常之后的操作 2.异常抛出后会一直返回调用函数(或者说上一层函数),直到被catch到,所以便可以统一将catch语句写在一起,使代码更加方便整洁。 1....
  • JAVA语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗? try catch 异常处理try catch 或者throws try: 将可能发生异常的代码 用{}包裹起来 catch:捕获...

    JAVA语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗?

    try catch

    • 异常处理try catch 或者throws
    • try: 将可能发生异常的代码 用{}包裹起来
    • catch:捕获特定的异常(如果预测多个异常先写范围小,后写范围大的)
    • 如果try中出现异常则程序将不继续执行try中的代码,而直接跳到catch里面

    throws throw

    • throws:用在方法上,表示此方法可能出现异常;但对方法出现的异常不做处理,上交给 上级(方法调用处main)处理

      public void test() throws Exception{
              
          }
      
    • throw:声明异常,使用在方法内部,jdk中有很多异常,如果这些内置的异常 仍然不能满足项目的需求,那么就需要创建 自定义异常。

      1. 继承Exception

        public class MyException extends Exception{
            public MyException(String message){
                //message异常信息
                super(message);
            }
        }
        
      2. 使用throw自定义异常

        //如何使用try或者throws
            public static void main(String[] args) {
                try {
                    int i = 0/1;
                    throw new MyException("运算错误");
                } catch (MyException e) {
                    e.printStackTrace();
                }
            }
        
        //运行结果
        com.xht.exception.MyException: 运算错误
        	at com.xht.test.Test.main(Test.java:21)
        

      finally

      ​ 无论运行是否正常都会执行的代码

      ​ 即使代码代码中有return 也会执行finally里面的代码

       //测试有return是否执行finally里面的代码 
    public static String test1(){
            try{
                return "hello";
            }catch (Exception e){
                e.printStackTrace();
                return "word";
            }finally {
                System.out.println("finally");
            }
        }
    

    运行结果:

        public static void main(String[] args) {
            test1();
        }
    
    //结果
    finally
    
    展开全文
  • java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供良好的接口。...java的异常处理是通过5个关键字来实现:try,catch,throw,throws,finally。一般情况下是用try来执行一段程序...
  • C++中try/catch/throw的使用

    万次阅读 多人点赞 2017-03-25 19:12:46
    C++异常处理涉及到三个关键字:try、catch、throw。 在C++语言中,异常处理包括: (1)、throw表达式:异常检测部分使用throw表达式来表示它遇到了无法处理的问题,throw引发了异常。throw表达...
  • throw try...catch...内存泄漏问题

    千次阅读 2013-07-20 12:00:13
    最近发现是在处理throw try catch异常事务时出现的,通过简单的编程测试可以证实throw try catch语句的内存泄漏问题,求教高手有什么好的解决方案?  测试例程如下: 对于throw try...catch...语句,存在内存...
  • 关于throw try catch

    千次阅读 2014-09-01 14:48:37
    如果在try块中(或者try块内部)
  • try catch throw用法

    千次阅读 2014-05-26 10:15:56
    要防止因为异常产生的内存泄漏,可以使用智能指针,也可以用  __try  {  }  __finally  ...《Windows核心编程》一书第23~25章是很好的参考资料。...try,catch,throw: try包含你要防护的代码 ,称为防护块. 防
  • 主要介绍了C++编程异常处理中trythrow以及catch语句的用法,包括对Catch块的计算方式的介绍,需要的朋友可以参考下
  • 主要介绍了C++异常处理 try,catch,throw,finally的用法,需要的朋友可以参考下
  • 如果throw语句抛出的异常时runtime异常,则该语句无须放在try块里或带throws抛出的方法中,程序可以显式使用 try…catch来捕获,并处理异常,也可以完全不理会该异常,把该异常交给该方法调用者处理。 6.throws与...
  • try 语句测试代码块的错误。 catch 语句处理错误。 throw 语句创建自定义错误。 finally 语句在 try 和 catch 语句之后,无论是否有触发异常,该语句都会执行。 JavaScript 抛出(throw)错误 当错误发生时,当事情...
  • 在Java中,每个异常都是一个对象,它是Throwable类或...将要被监听的代码(可能抛出异常的代码)放在try语句块之内,当try语句块内发生异常时,异常就被抛出。 • catch – 用于捕获异常。catch用来捕获try语句块中发...
  • Java 中 try-catch,throw和throws的使用

    千次阅读 多人点赞 2019-09-21 14:29:19
    关于异常的处理有try catch 程序块、throw 、throws。 以下分别对这三种进行介绍。 一、try...catch try-catch用来捕获代码段的异常并做出处理 try-catch代码块分两块,第一块是try{} ,第二块是catch(exception...
  •  我的理解:在try catch体系中,catch捕获到异常之后,要么自己处理掉,要么抛给调用该方法的上一级去处理,而throw就是实现这一过程的代码段。  对比:Throws用于声明方法可能会抛出什么类型的异常,Throw则是...
  • 每过一段时间,就总是会对try有点生疏,特别写了个程序来测试以下,有时候 throw是底层抛出来的,你不处理,默认就throw
  • try catch 嵌套 try catch 肯定可以嵌套的,可以先来个嵌套小测试。 public static void main(String[] args) { try { System.out.println("**********************外层try**********************");...
  • JavaScript 错误 – throwtry 和 catch try 语句测试代码块的错误。 catch 语句处理错误。 throw 语句创建自定义错误。 finally 语句在 try 和 catch 语句之后,无论是否有触发异常,该语句都会执行。  ...
  • throw | Error | try catch

    千次阅读 2020-09-16 11:28:47
    JS自定义异常try catchpromise then进入catch try catch try catch是ECMA-262第3版的时候引入的语法,用于捕捉js运行... //但有时会抛出一个异常,要么是由throw语句直接抛出,要么通过调用一个方法间接抛出 }catch(e
  • 【c#】异常处理:try catch throw

    千次阅读 热门讨论 2017-07-26 13:21:09
    异常处理,是编程语言或计算机硬件里的一种机制,用于处理软件或信息系统中出现的异常状况(即超出程序正常...异常处理的四个关键字:Try Catch Throw Finally Try:一个try块标识了一个将被激活的特定的异常的代码块
  • catch(int &Error) //此处也可以写成catch(int) 当遇到throw 1,也可以捕捉到错误 { cout ; } /////////第二个示例,throw在主程序中,多个catch函数 double Array[100]={1.2,1.3,1.4}; int n=30; try { ...
  • java异常捕获(6) trythrow共用

    千次阅读 2018-08-17 10:01:57
    throw new AuctionException("这是由throw关键字抛出的异常"); } if(iniPrice > d){ throw new AuctionException("这是由throw关键字抛出的异常2"); } iniPrice = d; } public static void main(String ...
  • JavaScript中try, catch, throw的用法

    千次阅读 2019-09-03 11:08:04
    try, catch, throw 便是 JavaScript 中用来调试并对错误执行相关操作的工具,下面具体介绍其用法; try, catch 基本语法结构: try { // ... // 这里写需要调试的代码段 } catch ( error ) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 653,949
精华内容 261,579
关键字:

throwtry