精华内容
下载资源
问答
  • python笔记——try except方法

    万次阅读 多人点赞 2019-06-02 20:49:53
    2、try except方法 一、常见错误总结 AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x IOError 输入/输出异常;基本上是无法打开文件 ImportError 无法引入模块或包;基本上是路径问题或...

    本文结构:
    1、常见错误总结
    2、try except方法

    一、常见错误总结


    • AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
    • IOError 输入/输出异常;基本上是无法打开文件
    • ImportError 无法引入模块或包;基本上是路径问题或名称错误
    • IndentationError 语法错误(的子类) ;代码没有正确对齐
    • IndexError 下标索引超出序列边界,比如当x只有三个元素,却试图访问x[5]
    • KeyError 试图访问字典里不存在的键
    • KeyboardInterrupt Ctrl+C被按下
    • NameError 使用一个还未被赋予对象的变量
    • SyntaxError Python代码非法,代码不能编译(个人认为这是语法错误,写错了)
    • TypeError 传入对象类型与要求的不符合
    • UnboundLocalError 试图访问一个还未被设置的局部变量,基本上是由于另有一个同名的全局变量,
      导致你以为正在访问它
    • ValueError 传入一个调用者不期望的值,即使值的类型是正确的

    二、try except方法


    有时候我们写程序的时候,会出现一些错误或异常,导致程序终止,这个时候我们需要捕获错误的类型,让代码更灵活,下面介绍下常用的try except来进行捕获异常的方法。

    1. 处理单个异常:

    • 语法:
    >>> try:
    >>>     code
    >>> except Error1 as e:  #处理Error1异常
    >>>     print(e)
    
    • demo
    >>> try>>>     print(5/0)           #该行为测试的语句
    >>> except  ZeroDivisionError as e:              ## 如果测试的语句出现except后的异常(例中的ZeroDivisionError),则执行下一行代码,否则跳过此模块
    >>>     print(e)               ## 打印错误名称
    division by zero        ##执行结果
    
    1. 分开处理多个异常:

    • 语法
    >>> try:
    >>>     code
    >>> except Error1 as e:  #处理Error1异常
    >>>     print(e)
    >>> except Error2 as e:   #处理Error2异常    
    >>>     print(e)
    
    • demo
    >>> a = [0,1]
    >>> try:
    >>>     print(a[3])  
    >>>     print(5/0)   ##语句在上一行就遇到错误传到except里面去了,未检测到此语句 
    >>> except ZeroDivisionError as e:  #处理Error1异常
    >>>     print(e)
    >>> except IndexError as e:   #处理Error2异常    
    >>>     print(e)
    list index out of range
    
    1. 统一处理多个异常:

    • 语法
    >>> try:
    >>>     code
    >>> except (Error1,Error) :    ###无论遇到什么异常,都只会执行下一行要打印的一种东西
    >>>     print(e)
    
    1. 没有异常,则走else部分的逻辑代码

    • 语法:
    >>> try:
    >>>     code
    >>> except (Error1,Error2,...) as e:
    >>>     print(e)
    >>> else:
    >>>     print("没有错误,执行")
    
    • demo
    >>>  try>>>     print(5/1)           
    >>> except  ZeroDivisionError as e:             
    >>>     print(e)              
    >>> else:
    >>>     print("没有错误")
    没有错误
    
    1. 不管有没有错误,都会执行finnally中的代码
      例如在对文件进行操作时候,如果文件读写过程中出现错误,无法关闭,可以将f.close()放在finally中,这样无论是否有错误,文件都会关闭

    >>> try:
    >>>     code
    >>> except (Error1,Error2,...) as e:
    >>>     print(e)
    >>> else:
    >>>     print("没有错误,执行")
    >>> finnally:
    >>>     print("不管有没有错,都执行finnally")
    
    展开全文
  • python中try except else的使用方法

    千次阅读 2019-11-27 09:56:00
    try: <语句> except <name>: <语句> #如果在try部份引发了名为'name'的异常,则执行这段代码 else: <语句> #如果没有异常发生,则执行这段代码 ##错误判断的代码 ##其中,想让文件写...

    try:
        <语句>
    except <name>:
        <语句>          #如果在try部份引发了名为'name'的异常,则执行这段代码
    else:
        <语句>          #如果没有异常发生,则执行这段代码

    ##错误判断的代码
    ##其中,想让文件写东西,在open一个文件的时候需要给r+
    try:
        file = open('/home/zbx/桌面/abcd','r+')
    except Exception as e:
        print("there is no file names as abcd")
        input_text = input("Do you want to new a file ?")
        if input_text == 'y':
            file = open('/home/zbx/桌面/abcd','w')
        else:
            pass
    else:
        file.write('ssss')
    file.close()

     

    展开全文
  • 工作中常常遇到方法的嵌套,方法中有各自的try-catch异常捕获,但是实际上并不能满足需要,如果遇到嵌套的结构,该如何设计 实例1: public class testTryCatch { public static void main(String[] args) { ...

    工作中常常遇到方法的嵌套,方法中有各自的try-catch异常捕获,但是实际上并不能满足需要,如果遇到嵌套的结构,该如何设计

    实例1:

    public class testTryCatch {
    
        public static void main(String[] args)  {
           try {
               childMain();
               System.out.println("这里是父类的代码块");
            }catch (Exception e){
                System.out.println("父try");
                //这里是我线程要捕获的东西------------
                e.printStackTrace();
            }finally {
               System.out.println("这里给我不管咋样执行");
           }
    
        }
    
        public static  void childMain() throws  Exception{
            try {
                Map<String,String> map  = new HashMap<String,String>();
                map.put("1111","1111");
                throw new RuntimeException();//这里模拟程序执行报错
            }catch (Exception e){
                System.out.println("子try");
                e.printStackTrace();
            }
        }
    }

    执行结果:

    子try
    java.lang.RuntimeException
        at com.bonc.properties.testTryCatch.childMain(testTryCatch.java:29)
        at com.bonc.properties.testTryCatch.main(testTryCatch.java:14)
    这里是父类的代码块
    这里给我不管咋样执行

    如上结果,如果主方法想在catch里执行一些操作,其实并不会执行,这个时候就需要修改子方法中的try-catch将异常向上抛出

    代码如下:

    public class testTryCatch {
    
        public static void main(String[] args)  {
           try {
               childMain();
               System.out.println("这里是父类的代码块");
            }catch (Exception e){
                System.out.println("父try");
                //这里是我线程要捕获的东西------------
                e.printStackTrace();
            }finally {
               System.out.println("这里给我不管咋样执行");
           }
        }
    
        public static  void childMain() throws  Exception{
            try {
                Map<String,String> map  = new HashMap<String,String>();
                map.put("1111","1111");
                throw new RuntimeException();//这里模拟程序执行报错
            }catch (Exception e){
                System.out.println("子try");
                e.printStackTrace();
                throw new Exception();
            }
        }
    }

    执行结果如下:

    子try
    java.lang.RuntimeException
    	at com.bonc.properties.testTryCatch.childMain(testTryCatch.java:28)
    	at com.bonc.properties.testTryCatch.main(testTryCatch.java:14)
    父try
    java.lang.Exception
    	at com.bonc.properties.testTryCatch.childMain(testTryCatch.java:32)
    	at com.bonc.properties.testTryCatch.main(testTryCatch.java:14)
    这里给我不管咋样执行

    从打印的结果可以看出,父方法的catch虽然捕获到了异常,但是很粗略,并不能精确定位

    因此再做一个修改:

    新建异常类:

    public class BoncExpection extends RuntimeException {
    	private static final long serialVersionUID = 0;
    	private String code;
    	private String msg;
    
    	public BoncExpection() {
    		super();
    	}
    	public BoncExpection(String code, String msg) {
    		super();
    		this.code = code;
    		this.msg = msg;
    	}
    	public String getCode() {
    		return code;
    	}
    	public void setCode(String code) {
    		this.code = code;
    	}
    	public String getMsg() {
    		return msg;
    	}
    	public void setMsg(String msg) {
    		this.msg = msg;
    	}
    }
    public class testTryCatch {
        public static void main(String[] args)  {
           try {
               childMain();
               System.out.println("这里是父类的代码块");
            }catch (BoncExpection e){
                System.out.println("父try");
                //这里是我线程要捕获的东西------------
               System.out.println(e.getMsg());
                e.printStackTrace();
            }finally {
               System.out.println("这里给我不管咋样执行");
           }
        }
        public static  void childMain() throws  BoncExpection{
            try {
                Map<String,String> map  = new HashMap<String,String>();
                map.put("1111","1111");
                throw new RuntimeException();//这里模拟程序执行报错
            }catch (Exception e){
                System.out.println("子try");
                BoncExpection boncExpection = new BoncExpection();
                boncExpection.setMsg(getExceptionMessage(e));
                throw  boncExpection;
            }
        }
        public static String getExceptionMessage(Exception e){
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            e.printStackTrace(new PrintStream(baos));
            String exception = baos.toString();
            return  exception;
        }
    }

    执行结果:

    子try
    父try
    java.lang.RuntimeException
    	at com.bonc.properties.testTryCatch.childMain(testTryCatch.java:33)
    	at com.bonc.properties.testTryCatch.main(testTryCatch.java:18)
    
    com.bonc.common.utils.BoncExpection
    	at com.bonc.properties.testTryCatch.childMain(testTryCatch.java:37)
    	at com.bonc.properties.testTryCatch.main(testTryCatch.java:18)
    这里给我不管咋样执行

    如上结果,子方法的异常直接和父方法的异常一起打印,也方便查看,因此在实际开发中搭配灵活使用即可

    版权声明:本文为博主原创文章,转载请注明本页地址。https://blog.csdn.net/l1994m/article/details/103407577

    展开全文
  • 下面是Java异常层析结构的一个简单示意图: 由图可知,所有异常类都直接或间接的继承于Throwable类。 具体分类: Java把所有非正常情况分为Error(错误) 和 Exception(异常) Error Error类层次结构描述了...

    在Java程序语言设计中,所有的异常都是由类来表示,异常对象都是派生于Throwable类的一个实例。下面是Java异常层析结构的一个简单示意图:

    由图可知,所有异常类都直接或间接的继承于Throwable类。


    具体分类:

    Java把所有非正常情况分为Error(错误) 和 Exception(异常)

    Error

    Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误,应用程序不应该抛出此类型的对象。这种情况一般很少出现。

    • VirtualMachineError(虚拟机错误)
    • ThreadDeath(线程锁死)

    Exception

    Exception类层次结构又分为两个分支 RuntimeException(运行时异常)和其他异常(代表:IOException )。

    派生于RuntimeException的常见异常的有以下几个

    • ClassCastException(类型转换异常)
    • IndexOutOfBoundsException(下标越界异常)
    • NullPointerException(空指针异常)

    若是出现RuntimeException异常,那么一就定是你的问题,这是一条相当由道理的规则。

    不派生于RuntimeException的异常有

    • IOException(I /O流异常)
    • 试图在文件尾部后面读取数据
    • 试图打开一个不存在的文件
    • 试图根据指定的字符串查找Class对象,而这个字符串表示的对象不存在。

    Java语言规范将派生于Error类 或RuntimeException类的所有异常成为非受察(unchecked)异常,所有其他异常称为受察(checked)异常。

    异常处理机制

    当程序出现异常时无非是将可能出现的异常抛出去不予理睬或者捕获可能出现的异常并加以处理。

    抛出:

    抛出异常依赖于throw和throws关键字 

    throw:抛出一个具体的异常对象,可以单独作为语句使用,可以在符合某种条件下抛出异常。

    throws:用在方法签名(方法名和参数列表统称为方法签名)中,声明该方法可能抛出的异常(类)。

    例1:

    /**
     * @author 北冥有熊
     *  2018年11月3日
     */
    public class ecxeptionTest {
    	
    	public static void main(String[] args) {
    		try {
    			mathException(10,0);
    		} 
    		catch (Exception e) {
    			System.out.println(e.getMessage()); //返回throwable详细信息字符串		
    			e.printStackTrace();  //将throwable对象的堆栈跟踪输出至错误输出流。
    		}
    	}
    	
    	public static void mathException(int a,int b) throws Exception{  //声明有可能抛出一个异常
    		if (b==0) {
    			//在此方法里面并没有对可能出现的异常进行处理,而是产生一个具体的异常对象并抛出给调用者
    			throw new Exception("除数不能为0");  
    		} else {
    			int num = a/b;
    			System.out.println(a+"/"+b+"=:"+num);
    
    		}
    	}
    	
    }
    
    
    

    其中,声明异常部分也可以声明多个异常,之间用 “,”隔开

    public static void mathException(int a,int b) throws Exception,OtherException{}

    捕获并处理:

    捕获处理异常依赖于try、catch、finally等关键字

    try:存放需要捕获指定异常的语句块。

    catch:捕获异常对象,并加以处理,chtch语句可以定义多个,针对不同异常如果有不同的处理手段。

    finally:在其里面的代码块必须执行

    /**
     * @author 北冥有熊
     *  2018年11月4日
     */
    public class exceptionTest01 {
    	public static void main(String[] args) {
    		try {
    			int a = 10;
    			int num = a/0; //发现异常,停止运行,转向catch语句块
    			System.out.println("-------1-------"); //不执行
    		} catch (Exception e) {
    			System.out.println("-------2-------"); //执行
    		}finally {
    			System.out.println("-------3-------"); //必须执行
    		}
    	}
    }

    结果是:

    -------2-------
    -------3-------

    值得注意的是,当try、catch语句块中有return时有如下特点:

    /**
     * @author 北冥有熊
     *  2018年11月4日
     */
    public class Test03 {
    	public static void main(String[] args) {
    		System.out.println(new Demo().getNum1());
    		System.out.println(new Demo().getNum2());
    	}
    }
    class Demo{
              //finally中没有return
             String getNum1(){
    		String t="";
    		try{
    			t="try";
    			return t; //此处返回的t并非上一句中的t,而是系统重新指定局部引用的t'
                                       //只不过t'指向了引用t对应的值,也就是try 
    		}catch(Exception e){
    			t="catch"; //不执行
    			return t;
    		}finally{
    			t="finally"; 
    			System.out.println("===="+t); // 输出t=finally,此处修改的是t而非t',
                                                        //t'虽然指向t但返回的是未修改的t'-----指向----->t="try"
    		}
    	}
            //fianlly中有return
    	String getNum2(){
    		String t="";
    		try{
    			t="try";
    			return t; //方法结束,去检查finally语句块中有没有return语句
    		}catch(Exception e){
    			t="catch"; //不执行
    			
    		}finally{
    			t="finally"; 
    			System.out.println("===="+t); // 输出t=finally
    			return t; // 返回修改后的t'指向上一句被修改过得t,并且返回[finally中一般不写return
                                    //此处警告,但能运行
    		}
    	}
    }
    getNum1方法结果:【finally中没有return】
    
                    ====finally  //t'-----指向----->t="try"被修改为finally
                    try  //在未修改t之前已经返回
    
    getNum2方法结果:【finally中有return】
    
                    ====finally  //t被修改为finally
                    finally   //修改之后并覆盖前面的return返回值
    

    对于上面代码的注解大家可能很疑惑,下面看用javap -verbose Test03来显示目标文件(.class文件)字节码信息:

    这里我们只看有效方法主体;

        public static java.lang.String main();
        descriptor: ()Ljava/lang/String;
        flags: ACC_PUBLIC, ACC_STATIC
        Code:
          stack=3, locals=4, args_size=0
             0: ldc           #5                  // String
             2: astore_0
             3: ldc           #6                  // String try
             5: astore_0
             6: aload_0
             7: astore_1
             8: ldc           #7                  // String finally
            10: astore_0
            11: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
            14: new           #8                  // class java/lang/StringBuilder
            17: dup
            18: invokespecial #9                  // Method java/lang/StringBuilder."<init>":()V
            21: ldc           #10                 // String ====
            23: invokevirtual #11                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
            26: aload_0
            27: invokevirtual #11                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
            30: invokevirtual #12                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
            33: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
            36: aload_1
            37: areturn
            38: astore_1
    
           ...
    
            88: ldc           #10                 // String ====
            90: invokevirtual #11                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
            93: aload_0
            94: invokevirtual #11                 // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
            97: invokevirtual #12                 // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
           100: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
           103: aload_3
           104: athrow
          Exception table:
             from    to  target type
                 3     8    38   Class java/lang/Exception
                 3     8    74   any
                38    44    74   any
          
          LocalVariableTable:
            Start  Length  Slot  Name   Signature
               39      35     1     e   Ljava/lang/Exception;
                3     102     0     t   Ljava/lang/String;
       
    }
    

    首先看LocalVariableTable信息,这里面定义了两个变量 一个是e Exception 类型,一个是t String类型

    接下来看方法主体Code部分:

    • 第[0-2]行:从常量池入口#5取出内容推到栈顶,将"null"引用传递给给第0个变量,也就是String t = "";
    • 第[3-6]行:从常量池入口#6取出内容推到栈顶,也就是执行try语句块,将"try"引用传递给第0个变量。
    • 第[7]行:重点是第7行,将"try"付给第1个变量(astore_1),但是这里面第1个变量并没有定义,(纳闷中...?)
    • 第[8-10] 行:对第0个变量进行赋值操作,也就是t="finally"。
    • 第[36-37]行:把第1个变量对应的值返回

    通过字节码,我们发现,在try语句的return块中,return 返回的引用变量(t 是引用类型)并不是try语句外定义的引用变量t,而是系统重新定义了一个局部引用t’,这个引用指向了引用t对应的值,也就是try ,即使在finally语句中把引用t指向了值finally,因为return的返回引用已经不是t ,所以引用t的对应的值和try语句中的返回值无关了。

    总结:

    1. finally语句块中的代码是必须执行的,当在try语句块总中出现异常,代码停止当前运行,转向catch语句块,再转向finally语句块。
    2. 在try、catch、finally中,若try、catch中有return时,且执行到return时,首先会检查finally语句块中有没有return,若finally中没有就返回try、catch语句块中的return返回值;若finally语句块中有return,则finally中的return值会覆盖try、catch中的return返回值。
    3. 若try、catch中有异常信息时,finally块中应避免使用return语句,因为finally块中如果使用return语句,会显示的屏蔽掉try、catch块中的异常信息,这并不是我们想要的。
    展开全文
  • Python中try语句的用法

    千次阅读 2019-07-13 01:04:40
    1. try except语句的用法,用来检测一段代码内出现的异常并将其归类输出相关信息,首先是try: 被检测代码段 except Exception[as reason]: 相关信息,举例说明: try: f = open('该文档不存在') print(f.read()) ...
  • 异常处理方式1 try-catch-finally 1,Java采用的异常处理机制,是将异常处理的程序代码集中在一起,与正常的程序代码分开, 过多的if-else分支会导致程序的代码加长、臃肿,可读性差。因此采用异常处理机制。使得...
  • try… except异常处理结构
  • 浅谈Java中try catch 的用法

    万次阅读 多人点赞 2018-11-10 15:37:21
    我们编译运行程序出错的时候,编译器就会抛出异常。...比如:使用了NULL引用或者是数组越界等。 异常有两种类型:未检查异常和已检查异常对于已检查异常,处理器器将会检查是否提供了处理器。 然而有许多...
  • try catch 合理使用

    2018-11-06 13:57:16
    什么时候使用try catch语句模块,是不是没有明确的答案? 来自网友的回答:try catch是程序语言本身提供的一种异常处理机制,你大多数写的代码都是要调用底层的api,而这些api的作者在开发api时,很清楚api在使用的...
  • C#中try catch finally 用法

    千次阅读 2017-12-09 10:54:59
    C#中try catch finally 用法 1、将预见可能引发异常的代码包含在try语句块中。  2、如果发生了异常,则转入catch的执行。 catch有几种写法: catch 这将捕获任何发生的异常。 catch(Exception e)...
  • python的try....except、raise的用法

    千次阅读 2018-01-22 16:51:17
    一、try...except 有时候我们写程序的时候,会出现一些错误或异常,导致程序终止。例如,做除法时,除数为0,会引起一个ZeroDivisionError 例子: 1 2 3 4 a=10 b=0 ...
  • 由运行结果可知,当异常处理结束后,程序会继续执行,直到输入为循环结束的标记 ''' try…多个exception结构 try…except结构可以捕获所有的异常,也是常见的结构。但是,一般建议尽量捕获可能出现的多个异常(按照...
  • try catch throw用法

    2018-01-11 14:42:44
    try catch throw用法 要防止因为异常产生的内存泄漏,可以使用智能指针,也可以用  __try  {  }  __finally  {  }  《Windows核心编程》一书第23~25章是很好的参考资料。 -----------------...
  • php try catch finally 结构

    2019-07-20 22:50:43
    code 1 <?php function foo(){ $bar = 1; try{ throw new Exception('I am Wu Xiancheng.'); }catch(Exception $e){ return $bar; $bar--; //...
  • try语句的基本用法

    千次阅读 2015-07-22 22:44:48
     try…catch…finally恐怕是大家再熟悉不过的语句了,而且感觉用起来也是很简单,逻辑上似乎也是很容易理解。不过,我亲自体验的“教训”告诉我,这个东西可不是想象中的那么简单、听话。不信?那你看看下面的代码...
  • 什么是异常? 异常是指在程序运行过程中,发生错误会...try:一个try块标识了一个将被激活的特定的异常的代码块。后跟一个后多个catch块。简单的说就是可能会出现错误的代码块要放在try中。 catch:程序通过异常...
  • c# try catch 用法

    千次阅读 2017-04-06 18:00:03
    trycatchfinally1、将预见可能引发异常的代码包含在try语句块中。2、如果发生了异常,则转入catch的执行。catch有几种写法:catch这将捕获任何发生的异常。catch(Exception e)这将捕获任何发生的异常。另外,还提供e...
  • Java中try-catch结构

    2016-02-17 22:33:59
    Java中try-catch结构 我们可以使用多个catch块来捕获异常, 这时需要将父类型的catch块放到子类型的catch块之后, 这样才能保证后续的catch块可能被执行, 否则子类型的catch将永远无法到达, Java编译器会报编译错误;...
  • JavaScript中try, catch, throw的用法

    千次阅读 2019-09-03 11:08:04
    JavaScript中关于错误的调试方法
  • 最近做毕设项目时发现,在利用try-catch结构语句进行数据库的事务提交时,出现了这么一个问题:一次删除多张表中的关联内容,从执行结果中查看也确实是已经被删除掉,按理说代码到此就应该结束返回,但程序总是会...
  • try { PageHelper.startPage(dto.getPageNum(), dto.getPageSize()); List<MdaDataAcquisitionDTO> list = mdaDataAcquisitionService.getPage(dto); PageInfo<MdaDataAcquisitionDTO> pageInfo = ...
  • try-catch-finally的用法

    2020-10-28 16:42:38
    try-catch-finally结构是Java提供来处理异常的,结构大致如下: try{ //代码执行区域 }catch(Exception e){ //异常处理区域 }finally{ //无论如何都会执行的代码区域 } 1、执行顺序 在Java程序中,有两种异常...
  • ABAP抓取异常的方法try,endtry

    千次阅读 2018-07-19 11:24:11
    在程序中使用RAISE EXCEPTION 手动抛出这类异常时,方法或过程接口上一定要显示的通过RAISING 来向上层抛出异常(或者直接在方法或过程中进行处理也可以),否则静态编译时就会出现警告。   CX_NO_CHECK...
  • try结构中声明的变量,再出了try结构以后,就不能再被调用 try-catch-finally结构可以嵌套 注意1:使用try-catch-finally处理编译时异常,是得程序在编译时就不再报错,但是运行时仍可能报错。 相当于我们使用...
  • 在Python项目中,有时候会出现异常,这时候作为一名程序员,学会处理异常非常重要,下面给大家介绍try,except,else,finally的用法。 首先介绍一下每个单词块的意思: try:把可能出现的异常代码放进try中,代表异常...
  • try-catch基础用法

    2017-08-07 11:00:43
     如果不使用这种try结构时,代码报错退出就无法继续执行。有的代码出错就应该退出,有的出错尚可以补救,就不应该退出。对于这种出错不应该退出的就需要使用这种结构,在catch中进行补救。 1 二:使用try ...
  • 直接在try和catch之间填充需要捕获异常的代码,之后如果有异常直接走catch分支,进行异常捕获。 如:  try{ //需要捕获异常的代码 } catch (Exception e) { System.out.println(e.getMessage()); } 解释...
  • 语法:Try{可能出现异常区域} catch(Exception e){异常提示,可以不写} … (catch可以有多个) finally{资源清理,JDBC/IO}(可以不写) 异常结构: Exception,Error是Throwable的子类 注:Exception:一般...
  • vc中关于try/catch结构使用

    千次阅读 2009-09-08 14:03:00
    在VC的Release版本中,会对try/catch结构进行优化,如果try块中没有显示的抛出异常,则会将catch块优化掉,也就是在实际运行中会捕获不到异常,如下:try{ char * p = NULL; p[0] = 0;}catch(...){ ...}在Debug...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 417,434
精华内容 166,973
关键字:

try的用法结构