全局异常捕捉
C# Winform全局捕捉异常
在有的操作系统中winform程序出现异常的时候，并不会弹出异常对话框，而是直接退出了，没有任何迹象，但是在系统的事件查看器（eventvwr.exe）中会发现这个异常。
为了能够捕捉到程序的异常，我们需要加一个全局异常的捕捉代码，当软件无故退出的时候，这样就能发现异常出现的具体位置。
网上有一些代码，但是没有说明具体的用法，有的是创建了一个异常捕捉类，在程序入口点去实例化。但是我们大多不愿意去多创建这个类，这个时候只要在Program.cs文件中添加代码去捕捉就行了，捕捉到了之后直接注释掉，简单，实用。
下面是整理过的：
在Program.cs中添加捕捉异常代码，添加后的类如下
using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Diagnostics;
using System.Threading;
using System.IO;
namespace logtest
{
static class Program
{
///
/// 应用程序的主入口点。
///
[STAThread]
static void Main()
{
//try
//{
// //处理未捕获的异常
// Application.SetUnhandledExceptionMode(UnhandledExceptionMode.CatchException);
// //处理UI线程异常
// Application.ThreadException += new System.Threading.ThreadExceptionEventHandler (Application_ThreadException);
// //处理非UI线程异常
// AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHan dler(CurrentDomain_UnhandledException);
#region Program.cs自动生成的代码
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// 程序入口点
Application.Run(new Form1());
#endregion
//}
//catch (Exception ex)
//{
// string str = "";
// string strDateInfo = "出现应用程序未处理的异常：" + DateTime.Now.ToString() + "\r\n";
// if (ex != null)
// {
// str = string.Format(strDateInfo + "异常类型：{0}\r\n异常消息：{1}\r\n异常信息：{2}\r\ n",
// ex.GetType().Name, ex.Message, ex.StackTrace);
// }
// else
// {
// str = string.Format("应用程序线程错误:{0}", ex);
// }
// MessageBox.Show(str, "系统错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
// writeLog(str);
//}
}
#region 捕捉全局异常代码
/////
/////
/////
//static void Application_ThreadException(object sender, System.Threading.ThreadExcept ionEventArgs e)
//{
// string str = "";
// string strDateInfo = "出现应用程序未处理的异常：" + DateTime.Now.ToString() + "\r\n"; // Exception error = e.Exception as Exception;
// if (error != null)
// {
// str = string.Format(strDateInfo + "异常类型：{0}\r\n异常消息：{1}\r\n异常信息：{2}\r\
n",
// error.GetType().Name, error.Message, error.StackTrace);
// }
// else
// {
// str = string.Format("应用程序线程错误:{0}", e);
// }
// MessageBox.Show(str, "系统错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
// writeLog(str);
//}
//static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEve ntArgs e)
//{
// string str = "";
// Exception error = e.ExceptionObject as Exception;
// string strDateInfo = "出现应用程序未处理的异常：" + DateTime.Now.ToString() + "\r\n"; // if (error != null)
// {
// str = string.Format(strDateInfo + "Application UnhandledException:{0};\n\r堆栈信息: {1}", error.Message, error.StackTrace);
// }
// else
// {
// str = string.Format("Application UnhandledError:{0}", e);
// }
// MessageBox.Show(str, "系统错误", MessageBoxButtons.OK, MessageBoxIcon.Error);
// writeLog(str);
//}
/////
///// 写文件
/////
/////
//static void writeLog(string str)
//{
// string ErrPath = AppDomain.CurrentDomain.BaseDirectory;
// if (!Directory.Exists(ErrPath))
// {
// Directory.CreateDirectory(ErrPath);
// }
// using (StreamWritersw = new StreamWriter( @"D:\ErrLog.txt", true))
// {
// sw.WriteLine(str);
// sw.WriteLine("---------------------------------------------------------");
// sw.Close();
// }
//}
#endregion
上面加注释的部分就是异常捕捉的代码，当程序中任何位置出现异常时，会弹出对话框，报出异常的位置，大大方便了代码的调试。
writeLog()方法是把异常的信息输出到日志文件，我是不需要，直接在弹出的对话框中就可以看见异常的位置了，不过可是使用，注意要保证路径正确并且有写入的权限。
EventType clr20r3 P1....P2...PN
java异常处理例题代码
App9_1.java：输出一个数组的所有元素，捕获数组下标越界异常和除娄为0异常。public class App9_1{ public static void main(String args[]){ int i; int[] a={1,2,3,4}; for(i=0;i<5;i++) System.out.println(" a["+i+"]="+a[i]); System.out.println("5/0"+(5/0)); } } App9_2.java：使用try-catch-finall语句对程序中的异常进行捕获与处理。 public class App9_2{ public static void main(String args[]){ int i; int a[]={1,2,3,4}; for (i=0;i<5;i++){ try{ System.out.print("a["+i+"]/"+i+"="+(a[i]/i)); } catch(ArrayIndexOutOfBoundsException e){ System.out.print("捕获到了数组下标越界异常"); } catch(ArithmeticException e){ System.out.print("异常类名称是："+e); //显示异常信息 } catch(Exception e){ System.out.println("捕获"+e.getMessage()+"异常！"); //显示异常信息 } finally{ System.out.println(" finally i="+i); } } System.out.println("继续！！"); } } App9_3.java：使用throw语句在方法中抛出异常。 public class App9_3{ public static void main(String args[]){ int a=5,b=0; try{ if (b==0) throw new ArithmeticException(); //抛出异常，不是必须的 else System.out.println(a+"/"+b+"="+a/b); //若不抛出异常，则运行此行
日志记录与异常处理规范(精)
日志记录与异常处理规范(2006-09-19 10:02:15转载日志记录与异常处理规范 1 日志记录规范规范日志设计规范主要目的是节省工作量，帮助对问题进行诊断。最终，终端用户可以获得更好的应用程序，并能从技术支持团队获得迅速的响应。 1.1 日志API 在使用 Java 平台进行开发时，使用的日志 API：Log4j-1. 2.8.jar 1.2 日志分类 l Security：记录外部对系统进行的各项操作 l Business：记录和跟踪业务逻辑执行过程 l Performance：记录和跟踪代码执行情况 1.3 日志级别日志级别有： l Debug: 包含了非常广泛的上下文信息，用于问题诊断。 l Info: 用于在产品环境中（粒度较粗）帮助跟踪执行过程的上下文消息。 l Warning: 警告消息，说明系统中可能存在问题。例如，如果这个消息类别是有关安全性方面的。 l Error: 错误消息说明系统中出现了严重的问题。这种问题通常都是不可恢复的，需要人工进行干预。表1 日志记录程序 public class Log4JTest { // Logging 类由EMIP平台提供Logging logging = Logging.getInstance("STDOUT"; public void testLogging( { //安全日志 https://www.sodocs.net/doc/cd10564709.html,("安全类型INFO级日志记录"; https://www.sodocs.net/doc/cd10564709.html,(Logging. SECURITY,"安 全类型INFO级日志记录"; https://www.sodocs.net/doc/cd10564709.html,(Logging. SECURITY,"安全类型INFO级日 志记录",new RuntimeException(; logging.error("安全类型ERROR级日志记录"; logging.error(Logging. SECURITY,"安全类型ERROR级日志记录"; logging.error(Logging. SECURITY,"安全类型ERROR级日志记录",new RuntimeException(; //业务日志 https://www.sodocs.net/doc/cd10564709.html,("业务类型INFO级日志记录"; https://www.sodocs.net/doc/cd10564709.html,(Logging. BUSINESS,"业务类型INFO级日志记录"; https://www.sodocs.net/doc/cd10564709.html,(Logging. BUSINESS,"业务类型INFO级日志记录",new RuntimeException(; logging.error("业 务类型ERROR级日志记录"; logging.error(Logging. BUSINESS,"业务类型ERROR 级日志记录"; logging.error(Logging. BUSINESS,"业务类型ERROR级日志记录",new RuntimeException(; //系统日志 https://www.sodocs.net/doc/cd10564709.html,("业务类型INFO级日志记录"; https://www.sodocs.net/doc/cd10564709.html,(Logging. BUSINESS,"业务类型INFO级日志记录"; https://www.sodocs.net/doc/cd10564709.html,(Logging. BUSINESS,"业务类型INFO级日志记录",new RuntimeException(; logging.error("业 务类型ERROR级日志记录"; logging.error(Logging. BUSINESS,"业务类型ERROR 级日志记录"; logging.error(Logging. BUSINESS,"业务类型ERROR级日志记录",new RuntimeException(; https://www.sodocs.net/doc/cd10564709.html,("系统类型INFO级日志记录";
异常处理练习题
异常处理练习题 一、选择题 中用来抛出异常的关键字是 A、try B、catch C、throw D、finally 2.关于异常，下列说法正确的是 A、异常是一种对象 B、一旦程序运行，异常将被创建 C、为了保证程序运行速度，要尽量避免异常控制 D、以上说法都不对 3.（）类是所有异常类的父类。 A、Throwable B、Error C、Exception D、AWTError 语言中，下列哪一子句是异常处理的出口 A、try{…}子句 B、catch{…}子句 C、finally{…}子句 D、以上说法都不对 5.下列程序的执行，说法正确的是 public class MultiCatch { public static void main(String args[]) { try { int a=; int b=42/a; int c[]={1}; c[42]=99; } catch(ArithmeticException e) { 除0异常：”+e); } catch(ArrayIndexOutOfBoundsException e) { 数组超越边界异常：”+e); } } } A、程序将输出第15行的异常信息 B、程序第10行出错 C、程序将输出“b=42” D、程序将输出第15和19行的异常信息 6.下列程序的执行，说法正确的是 class ExMulti { static void procedure() { try {
int c[]={1}; c[42]=99; } catch(ArrayIndexOutOfBoundsException e) { 数组超越界限异常：”+e); } } public static void main(String args[]) { try { procedure(); int a=; int b=42/a; } catch(ArithmeticException e) { 除0异常：”+e); } } } A、程序只输出第12行的异常信息 B、程序只输出第26行的异常信息 C、程序将不输出异常信息 D、程序将输出第12行和第26行的异常信息 7.下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。class TrowsDemo { static void procedure() throws IllegalAccessException { procedure”); throw____new___IllegalAccessException(“demo”); } public static void main(String args[]) { try { procedure(); } ___catch (IllegalAccessException e)________ { 捕获：”+e); } } 8.对于catch子句的排列，下列哪种是正确的( ) A、父类在先，子类在后 B、子类在先，父类在后
对捕获异常、异常处理的理解
对捕获异常、异常处理的理解 要求：请阅读以下材料作答 程序可能按编程者的意愿终止，也可能因为程序中发生了错误而终止。例如，程序执行时遇到除数为0或下标越界，这时将产生系统中断，从而导致正在执行的程序提前终止。程序的错误有两种，一种是编译错误，即语法错误。如果使用了错误的语法、函数、结构和类，程序就无法被生成运行代码。另一种是在运行时发生的错误，它分为不可预料的逻辑错误和可以预料的运行异常。在编写程序时，应该考虑确定程序可能出现的错误，然后加入处理错误的代码。也就是说，在环境条件出现异常情况下，不会轻易出现死机和灾难性的后果，而应有正确合理的表现。 要求： 1、阐述如何捕获异常。 2、阐述异常处理的基本思想有哪些。 3、阐述异常处理的机制。 一、捕获异常：检查异常与非检查异常 检查异常对方法调用者来说属于必须处理的异常，当一个应用系统定义了大量或者容易产生很多检查异常的方法调用，程序中会有很多的异常处理代码。如果一个异常是致命的且不可恢复并且对于捕获该异常的方法根本不知如何处理时，或者捕获这类异常无任何益处，笔者认为应该定义这类异常为非检查异常，由顶层专门的异常处理程序处理；像数据库连接错误、网络连接错误或者文件打不开等之类的异常一般均属于非检查异常。这类异常一般与外部环境相关，一旦出现，基本无法有效地处理。 而对于一些具备可以回避异常或预料内可以恢复并存在相应的处理方法的异常，可以定义该类异常为检查异常。像一般由输入不合法数据引起的异常或者与业务相关的一些异常，基本上属于检查异常。当出现这类异常，一般可以经过有效处理或通过重试可以恢复正常状态。 由于检查异常属于必须处理的异常，在存在大量的检查异常的程序中，意味着很多的异常处理代码。另外，检查异常也导致破坏接口方法。如果一个接口上的某个方法已被多处使用，当为这个方法添加一个检查异常时，导致所有调用此方法的代码都需要修改处理该异常。当然，存在合适数量的检查异常，无疑是比较优雅的，有助于避免许多潜在的错误。 到底何时使用检查异常，何时使用非检查异常，并没有一个绝对的标准，需要依具体情况而定。很多情况，在我们的程序中需要将检查异常包装成非检查异常抛给顶层程序统一处理；而有些情况，需要将非检查异常包装成检查异常统一抛出。 二、理解异常从中找到处理方式 从应用系统最终用户的角度来看，用户所面对的是系统中所提供的各种业务功能以及系统本身的管理功能。用户并不理解系统内部是如何实现以及如何运行的，与系统开发者存在天然的鸿沟，系统运行对用户来说如同一个黑盒一样。对用户而言，系统所出现的任何异常或错误，都属于系统运行时异常。对于这些异常，有些异常是用户可以理解并能解决的；而另外一些异常是用户无法理解和解决的。当一个系统错误出现时，系统本身需要反馈给用户一种可理解的业务相近的信息，从而用户可以根据这些信息去尽可能解决问题。另一方面，有一类错误属于系统内部运行异常或错误，用户对此类错误根本无能为力。而这类异常同样需要提供足够详细的信息，系统管理员可根据这类异常尽可能解决。一般情况下，如果异常面向系统用户，以系统异常呈现更好。 从系统开发者角度来看，更多的是从系统内部逻辑来看异常。有一部分异常需要内部截获处理，而另外一部分异常对于异常产生源而言无法进行有效处理，从而需要向外抛出异常以待合适的调用者进行处理。对于开发者而言，需要预见异常，并且需要考虑何时处理异常，何时抛出异常，必要时以某种方式记录或通知异常。总而言之，开发者需要通过对系统运行时可能出现的异常尽可能地处理以保证系统的正常运行，并对于无法处理的异常以一种合适的方式记录、通知、呈现以便找到发生异常的原因，从而解决或避免异常。 三、异常处理机制 我们可以认为异常包含三部分：异常Service、异常处理过滤器、系统异常层次定义。
图片的获取与处理习题
主题五：图片的获取与处理习题 1、如图：用ACDSee处理图①，使之变化到图②的过程中所进行的操作有（C） A、水平翻转和移动 B、调整大小和裁剪 C、水平翻转和调整大小 D、旋转和裁剪 2、关于位图与矢量图，下面正确的说法是 (B) A、位图放大后不易失真 B、矢量图放大后不易失真 C、要减小文件大小，可用位图 D、矢量图是由像素排列组合成的 3、图片文件有多种格式，下面正确的说法是(D) A、BMP格式文件是经过压缩的 B、将一张BMP格式的图片转换成JPG格式后文件变大 C、用GIF格式描述照片效果最佳 D、BMP格式文件属于位图文件 4、在WWW 上浏览和下载信息时，下列说法正确的是（D） A.必须用专门的下载软件才能下载网上的共享软件 B.网络信息只能以网页形式（.htm）另存到本地硬盘 C.无法脱机浏览从网上下载的信息 D.通常情况下，可通过右击网页上的图片，将其另存到本地硬盘 5、小华从因特网上下载了以下四个文件，哪个不属于图像文件（C） A.中国地图.jpg B.小猪.gif C.白雪公主.doc D.清华大学.bmp 6、下列说法中，错误的是（B） A.ACDSee6.0是一款看图工具软件，可用于图片的管理和处理 B.Windows自带的"画图"程序，所保存文件的默认格式是PSD C."我形我速"是简洁好用的相片编辑软件，能将普通的相片处理成精美的艺术照 D.Photoshop采用图层处理技术处理图片 7、刘明去北京观看奥运会的时候拍了很多照片，其中有部分照片被他拍斜了，用ACDSee6.0中的哪种操作可以将其调正?( A) A.旋转/翻转 B.转换文件格式 C.调整大小 D.曝光 8、关于ACDSee6.0软件，下列描述错误的是（D） A.可以通过调整图像的亮度、对比度等来美化图片 B.可以通过转换文件格式命令将bmp格式文件转换为JPG格式文件 C.可以对图像进行任意角度旋转 D.可以通过裁剪工具从原图像中裁剪出椭圆形图像来 9、用ACDSee6.0软件，下列哪种操作可以将BMP格式文件转换成JPG格式文件?( B) A.更改文件扩展名 B.转换文件格式 C.调整大小 D.裁剪 10、如图：用ACDSee6.0处理图①，使之变化到图②的过程中所进行的操作是（C）
数据库异常处理答案
一、实验/实习过程 实验题1在程序中产生一个ArithmeticException类型被0除的异常，并用catch 语句捕获这个异常。最后通过ArithmeticException类的对象e 的方法getMessage给出异常的具体类型并显示出来。 package Package1; public class除数0 { public static void main(String args[]){ try{ int a=10; int b=0; System.out.println("输出结果为："+a/b); } catch(ArithmeticException e){ System.out.println("除数不能为0"+e.getMessage()); } } } 实验题2在一个类的静态方法methodOne（）方法内使用throw 产生ArithmeticException异常，使用throws子句抛出methodOne（）的异常，
在main方法中捕获处理ArithmeticException异常。 package Package1; public class抛出异常 { static void methodOne() throws ArithmeticException{ System.out.println("在methodOne中"); throw new ArithmeticException("除数为0"); } public static void main(String args[]){ try{ int a=10; int b=0; int c=1; System.out.println("输出结果为："+a/b); } catch(ArithmeticException e){ System.out.println("除数不能为0"+e.getMessage()); } } }
Java作业实验六---异常处理
提交方式： 把文件名改为学号姓名，提交文档和源码(只需提交最顶层包文件夹） 实验六异常处理 一、实验目的 1.学会利用Try-catch-finally语句来捕获和处理异常； 2.掌握自定义异常类的方法。 二、实验要求 1.通过编程理解系统异常处理的机制和创建自定义异常的方法。 2.掌握基础类。 三、实验内容 （一）异常处理机制 1. 编写使用try…catch 语句处理异常的程序文件Demo4_1.java，
编译并运行程序，并把运行结果复制在下面 。 注意：如果在catch 语句中声明的异常类是Exception，catch 语句也能正确地捕获，这是因为Exception是ArithmeticException的父类。如果不能确定会发生哪种情况的异常，那么最好指定catch的参数为Exception，即说明异常的类型为Exception。 2、源文件是Demo3_2.java。要捕捉的异常是除数为零和数组下标越界。通过修改a和c[]下标值体验程序。 【思考】 ①先运行上面程序，观察运行结果。 ②按下条件分别修改数据，编译后运行，观察输出结果，分析在try…catch块里那些语句没有被执行，为什么? 块外那些语句可被执行到，为什么? 修改a=0，保持c[2]=200； 保持a=10，修改c[3]=200， 修改a=0，修改c[3]=200； ③再添加一个catch{Exception e}{ },位置在最前面，观察编译信息，说明什么？ 3、编写Demo3_3.java 程序，计算两数相除并输出结果。使用两个catch子句，分别捕捉除数为0的异常和参数输入有误异常。源代码如下：
java异常处理试题及答案
j a v a异常处理试题及答 案 This model paper was revised by the Standardization Office on December 10, 2020
异常处理练习题 一、选择题 中用来抛出异常的关键字是 (C) A、try B、catch C、throw D、finally 2.关于异常，下列说法正确的是(A) A、异常是一种对象 B、一旦程序运行，异常将被创建 C、为了保证程序运行速度，要尽量避免异常控制 D、以上说法都丌对 3.（A）类是所有异常类的父类。 A、Throwable B、Error C、Exception D、AWTError 语言中，下列哪一子句是异常处理的出口(C) A、try{…}子句 B、catch{…}子句 C、finally{…}子句 D、以上说法都丌对 5.下列程序的执行，说法错误的是 (C) public class MultiCatch
{ public static void main(String args[]) { try { int a=; int b=42/a; int c[]={1}; c[42]=99; } catch(ArithmeticException e) { 除0异常：”+e); } catch(ArrayIndexOutOfBoundsException e) {
数组超越边界异常：”+e); } } } A、程序将输出第15行的异常信息 B、程序第10行出错 C、程序将输出“b=42” D、程序将输出第15和19行的异常信息 6.下列程序的执行，说法正确的是（D）class ExMulti { static void procedure() { try { int c[]={1};
C# try…catch语句捕获异常
C# try …catch 语句捕获异常 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。例如，代码少了一个分号，那么运行出来结果是提示是错误；如果输入Console.WriteLine(11/0)语句输出内容，那么会判断出使用0做了除数，则抛出“尝试除以零”的异常。 在C#中，通常是采用try …catch 语句捕获异常并处理。当程序中抛出一个异常后，并从程序代码处跳出，C#虚拟机检测寻找和try 关键字匹配的处理该异常的catch 块。如果找到该异常，将控制权交到catch 块中的代码，然后继续往下执行程序，try 块中发生异常的代码不会被重新执行。如果没有找到处理该异常的catch 块，则执行当前线程的所属的ThreadGroup 对象中的uncaughtException 方法，将调用转发给 在以上语法中，把可能引发异常的语句封装在try 语句块中，用于捕获可能发生的异常。如果try 语句块中发生异常，那么，一个相应的异常对象就会被抛出。 然后catch 语句就会依据所抛出异常对象的类型进行捕获并处理。处理之后，程序会跳出try 语句块，转到catch 语句块后面的第一条语句开始执行。 如果try 语句块中没有异常发生，那么try 语句块正常结束，后面的catch 语句块被跳过，程序将从catch 语句块后的第一条语句开始执行。 在以上语法的处理代码块1中，可以使用以下3个方法输出相应的异常信息。 ● StackTrace()方法 指出异常的类型、性质、栈层次及出现在程序中的位置。 ● Message()方法 输出错误的信息。 ● toString()方法 给出异常的类型与信息。 下面通过创建一个实例，来说明try …catch 的使用。示例代码如下所示。
Java捕获异常处理的常用方法
Java捕获异常处理的常用方法 在Java中，异常情况分为Exception（异常）和Error（错误）两大类，Java 异常通常是指程序运行过程中出现的非正常情况，如用户输入错误、除数为零、需要处理的文件不存在、数组下标越界等，对于异常情况的出现，可以采用异常处理，以保证程序可以正常的执行。 Java中定义两种类型的异常和错误： 1. JVM(Java虚拟机) 异常：由JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。 2. 程序级异常：由程序或者API程序抛出的异常。例如IllegalArgumentException 类，IllegalStateException 类。 捕获异常的方法 使用 try 和 catch 关键字可以捕获异常，try/catch代码块中的代码称为保护代码，可以放在异常可能发生的地方，具体用法如下： try { // 程序代码 }catch(ExceptionName e1) { //Catch 块 }
catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。如果发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是一样。也可以进行多重捕获，具体用法是在try代码块后面跟随多个catch代码块。 catch 语句往往是和finally配合使用，finally关键字用来创建在try代码块后面执行的代码块，无论是否发生异常，finally代码块中的代码总会被执行，因此，在 finally 代码块中，可以运行清理类型等收尾善后性质的语句。 声明自定义异常 在Java中可以自定义异常，在自定义异常类时需注意以下几点： 1. 所有异常都必须是 Throwable 的子类； 2. 自定义检查性异常类，则需继承 Exception 类； 3. 自定义运行时异常类，则需继承 RuntimeException 类。 自定义的异常类和其他任何类都一样，包含有变量和方法。其作用机制均是抛出异常和捕捉异常，一个方法能捕捉异常，一定是Java代码在某处所抛出的异常，异常总是先被抛出，后被捕捉的。
java异常处理试题及答案
异常处理练习题 一、选择题 1.java中用来抛出异常的关键字是(C) A、try B、catch C、throw D、finally 2.关于异常，下列说法正确的是(A) A、异常是一种对象 B、一旦程序运行，异常将被创建 C、为了保证程序运行速度，要尽量避免异常控制 D、以上说法都丌对 3.（A）类是所有异常类的父类。 A、Throwable B、Error C、Exception D、AWTError 4.java语言中，下列哪一子句是异常处理的出口(C) A、try{…}子句 B、catch{…}子句 C、finally{…}子句 D、以上说法都丌对 页脚内容1
5.下列程序的执行，说法错误的是(C) public class MultiCatch { public static void main(String args[]) { try { int a=args.length; int b=42/a; int c[]={1}; c[42]=99; System.out.println(“b=”+b); } catch(ArithmeticException e) { System.out.println(“除0异常：”+e); } 页脚内容2
catch(ArrayIndexOutOfBoundsException e) { System.out.println(“数组超越边界异常：”+e); } } } A、程序将输出第15行的异常信息 B、程序第10行出错 C、程序将输出“b=42” D、程序将输出第15和19行的异常信息 6.下列程序的执行，说法正确的是（D） class ExMulti { static void procedure() { try { 页脚内容3
11-异常处理(jb)
第11章异常处理 (1) 11.1 C++的异常处理机制 (1) 11.2 异常处理的实现 (2) 第7章第11章异常处理 异常处理（exception handling）机制是用于管理程序运行期间出现非正常情况的一种结构化方法。C++的异常处理将异常的检测与异常处理分离，增加了程序的可读性。异常处理常用于大型软件的开发中。 本章介绍异常处理的基本概念，以及异常处理程序的构造。 11.1 C++的异常处理机制 软件开发不但要保证逻辑上的正确性，还必须具有容错能力。即要求应用程序不但在正常情况下能够正确运行，发生意外时也可以做出适当处理，不会导致丢失数据或破坏系统运行等灾难性的后果。这些意外可能由用户误操作、外部设备或文件的不正确连接，或者内存空间不足等原因所造成。异常包括错误，也可能是某些很少出现的特殊事件。 为了处理可以预料的异常，传统的程序设计中，经常使用中断指令。例如： abort assert exit return 典型的方法是被调用函数运行发生错误时，返回一个特定的值，让调用函数检测到错误标志后做出处理。或者当错误发生时，释放所有资源，结束程序执行。 这些处理方法使得异常处理代码分布在系统可能出错的各个地方。优点是处理直接，运行开销小，适用于处理简单的局部错误。缺点是错误处理代码掺杂于系统功能实现的代码主线，降低了程序的可读性和可维护性，不适用于组件式的大型软件开发。 如果设计的类是提供给其他程序员重用，使用传统的异常处理方式，虽然可以检测到异常条件的存在，但无法确定其他程序员如何处理这些异常；另一方面，这些程序员想按照自己的意愿处理异常，但又无法检测到异常条件是否存在。 异常处理的基本思想是将异常检测与处理分离。出现异常的函数不需具备处理异常的能力。当一个函数发生异常时，它抛出一个异常信息，希望它的调用者捕获并处理这个异常。如果调用者不能处理，还可以报告（抛出）给上一级调用者处理。一直到运行系统，若仍不能处理，将简单终止程序。 C++的异常处理是一种不唤醒机制。即抛出异常的模块一旦抛出了异常，将不再恢复运行。程序在异常处理模块执行处理代码后将继续执行。系统有序地释放调用链上的资源，包括函数调用栈的释放和调用析构函数删除已建立的对象。 例如，在图11.1的示意中，函数P，Q，…，R是一个调用链。R可以向它的上层调用如Q、P报告（抛出）异常。换句话说，Q、P可以捕捉并处理R的异常。图中，R抛出的异 1
Java异常处理总结(精)
Java 异常处理总结 找到一个关于异常总结的很详细的文章, 分享下. 异常在我们编程中很重，在适当的位置，合理的处理或者抛出异常，对程序来说至关重要。转：异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C 开始，你也许已经知道如何用if...else... 来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！ Java 语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个类型来表示，不同类型的异常对应不同的子类异常（这里的异常包括错误概念），定义异常处理的规范，在1.4版本以后增加了异常链机制，从而便于跟踪异常！这是Java 语言设计者的高明之处，也是Java 语言中的一个难点，下面是我对Java 异常知识的一个总结，也算是资源回收一下。 一、Java 异常的基础知识 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误https://www.sodocs.net/doc/cd10564709.html,ng.Error ；如果你用System.out.println(11/0，那么你是因为你用0做了除数，会抛出https://www.sodocs.net/doc/cd10564709.html,ng.ArithmeticException 的异常。有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。天有不测风云，人有旦夕祸福，Java 的程序代码也如此。在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。 Java 中的异常用对象来表示。Java 对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class ），每个异常都对应一个异常（类的）对象。 异常类从哪里来？有两个来源，一是Java 语言本身定义的一些基本异常类型，二是用户通过继承Exception 类或者其子类自己定义的异常。Exception 类及其
关于C++中的异常处理使用方法与技巧
1关于异常处理 1.1为什么要抛出异常 抛出异常的好处一是可以不干扰正常的返回值，另一个是调用者必须处理异常，而不像以前c语言返回一个整数型的错误码，调用者往往将它忽略了。 C++的异常处理确保当程序的执行流程离开一个作用域的时候，对于属于这个作用域的所有由构造函数建立起来的对象，它们的析构函数一定会被调用。 1.2捕获所有异常 有时候，程序员可能希望创建一个异常处理器，使其能够捕获所有类型的异常。用省略号代替异常处理器的参数列表就可以实现这一点： 由于省略号异常处理器能够捕获任何类型的异常，所以最好将它放在异常处理器列表的最后，从而避免架空它后面的异常处理器。 省略号异常处理器不允许接受任何参数，所以无法得到任何有关异常的信息，也无法知道异常的类型。它是一个“全能捕获者”。这种catch子句经常用于清理资源并重新抛出所捕获的异常。 1.3重新抛出异常 当需要释放某些资源时，例如网络连接或位于堆上的内存需要释放时，通常希望重新抛出一个异常。（详见本章后面的“资源管理”一节。）如果发生了异常，读者不必关心到底
是什么错误导致了异常的发生——只需要关闭以前打开的一个连接。此后，读者希望在某些更接近用户的语境（也就是说，在调用链中的更高层次）中对异常进行处理。在这种情况下，省略号异常处理器正符合这种的要求。这种处理方法，可以捕获所有异常，清理相关资源，然后重新抛出该异常，以使得其他地方的异常处理器能够处理该异常。在一个异常处理器内部，使 用不带参数的throw语句可以重新抛出异常： 与同一个try块相关的随后的catch子句仍然会被忽略—throw子句把这个异常传递给 位于更高一层语境中的异常处理器。另外，这个异常对象的所有信息都会保留，所以位于更高层语境中的捕获特定类型异常的异常处理器能够获取这个对象包含的所有信息。 1.4构造函数中的异常 C++规定构造函数抛出异常之后，对象将不被创建，析构函数也不会被执行，但已经创建成功的部分（比如一个类成员变量）会被部分逆序析构，不会产生内存泄漏。但有些资源需要在抛出异常前自己清理掉，比如打开成功的一个文件，最好关闭掉再抛出异常（虽然系统也会把这个资源回收），因为抛出异常之后析构函数不会被执行了。 （1）C++中通知对象构造失败的唯一方法那就是在构造函数中抛出异常；（这句话并不是说我们只有这个方法才能让上层知道构造函数失败，虽然构造函数没有返回值，我们完全可以在构造函数中传入一个引用值，然后在里面设置状态，运行完构造函数之后任然可以知道是否失败，但这种情况下面对象其实还是被构造出来的，只是里面有资源分配失败而已，并且析构函数还是会执行。这和我们构造失败不生成对象的初衷不符。）
异常处理参考答案
一、【必做题】 1．写出以下程序的运行结果。 Static double average(int[] a) throws NullPointerException { Try { Int sum = 0; for (int I = 0; I < a.length; i++) { Sum += a[i]; } Return (((double) sum) / a.length); } catch (NullPointerException e) { “NullPointerException”); throw e; } } Public static void main(String args[]) { Try { Int a[] = null; average(a); } catch (NullPointerException e ) { “NullPointerException”); } “OK”); } NullPointerException NullPointerException OK 2．编写一个方法，比较两个字符串。假如其中一个字符串为空，会产生NullPointerException异常，在方法声明中通告该异常，并在适当时候触发异常，然后编写一个程序捕获该异常。 public class Main { public static void test(String s,String a ) throws NullPointerException { if(s==null||a == null) { throw new NullPointerException(); }else{ } } public static void main(String[] args) { // TODO Auto-generated method stub try{ String s = null; String a = "asff"; test(s,a); }catch(NullPointerException e){ e.printStackTrace(); }
Java中如何正确处理异常
1 引言 在JAVA语言出现以前，传统的异常处理方式多采用返回值来标识程序出现的异常情况，这种方式虽然为程序员所熟悉，但却有多个坏处。 首先，一个API可以返回任意的返回值，而这些返回值本身并不能解释该返回值是否代表一个异常情况发生了和该异常的具体情况，需要调用API的程序自己判断并解释返回值的含义。 其次，并没有一种机制来保证异常情况一定会得到处理，调用程序可以简单的忽略该返回值，需要调用API的程序员记住去检测返回值并处理异常情况。这种方式还让程序代码变得晦涩冗长，当进行IO操作等容易出现异常情况的处理时，你会发现代码的很大部分用于处理异常情况的switch分支，程序代码的可读性变得很差。 上面提到的问题，JAVA的异常处理机制提供了很好的解决方案。通过抛出JDK 预定义或者自定义的异常,能够表明程序中出现了什么样的异常情况；而且JAVA 的语言机制保证了异常一定会得到恰当的处理；合理的使用异常处理机制，会让程序代码清晰易懂。 2 JAVA异常的处理机制 当程序中抛出一个异常后，程序从程序中导致异常的代码处跳出，java 虚拟机检测寻找和try关键字匹配的处理该异常的catch块，如果找到，将控制权交到catch块中的代码，然后继续往下执行程序，try块中发生异常的代码不会被重新执行。如果没有找到处理该异常的catch块，在所有的finally块代码被执行和当前线程的所属的ThreadGroup的uncaughtException方法被调用后，遇到异常的当前线程被中止。 3 JAVA异常的类层次 JAVA异常的类层次如下图所示： 图1 JAVA异常的类层次 Throwable是所有异常的基类，程序中一般不会直接抛出Throwable对象，Exception和Error是Throwable的子类，Exception下面又有RuntimeException 和一般的Exception两类。可以把JAVA异常分为三类： 第一类是Error，Error表示程序在运行期间出现了十分严重、不可恢复的错误，在这种情况下应用程序只能中止运行，例如JAVA 虚拟机出现错误。Error 是一种unchecked Exception,编译器不会检查Error是否被处理,在程序中不用捕获Error类型的异常；一般情况下，在程序中也不应该抛出Error类型的异常。 第二类是RuntimeException, RuntimeException 是一种unchecked Exception，即表示编译器不会检查程序是否对RuntimeException作了处理，在程序中不必捕获RuntimException类型的异常，也不必在方法体声明抛出RuntimeException类。RuntimeException发生的时候，表示程序中出现了编程错误，所以应该找出错误修改程序，而不是去捕获RuntimeException。 第三类是一般的checked Exception,这也是在编程中使用最多的Exception,所有继承自Exception并且不是RuntimeException的异常都是checked Exception，如图1中的IOException和ClassNotFoundException。JAVA 语言规定必须对checked Exception作处理，编译器会对此作检查，要么在方法体中
vb可捕获的错误
vb可捕获的错误 private sub fun() on error goto err '出现错误，转移到err . . . exit sub err: on error goto 0 '关闭错误捕获 if err.number=3721 then . . . end if end sub
vb可捕获的错误 可捕获的错误通常发生在应用程序运行时，但也有一些会发生在开发期间或编译时间。可使用On Error 语句与Err 对象来探测并回应可捕获的错误。1 –1000 之间未使用的错误号都是保留给Visual Basic 以后使用的。 代码信息 3没有返回的GoSub 5无效的过程调用 6溢出 7内存不足 9数组索引超出范围
10此数组为固定的或暂时锁定 11除以零 13类型不符合 14字符串空间不足 16表达式太复杂 17不能完成所要求的操作 18发生用户中断 20没有恢复的错误 28堆栈空间不足 35没有定义子程序、函数，或属性47DLL 应用程序的客户端过多
48装入DLL 时发生错误49DLL 调用规格错误 51内部错误 52错误的文件名或数目 53文件找不到 54错误的文件方式 55文件已打开 57 I/O 设备错误 58文件已经存在 59记录的长度错误 61磁盘已满
62输入已超过文件结尾 63记录的个数错误 67文件过多 68设备不可用 70没有访问权限 71磁盘尚未就绪 74不能用其他磁盘机重命名 75路径/文件访问错误 76找不到路径 91尚未设置对象变量或With 区块变量92For循环没有被初始化
异常处理的 15 个处理原则
见过很多人在进行异常处理的时候，直接一个e.printStackTrace() 就完成了，这是一种非常粗陋的做法，首先会导致应用日志的大量错误信息，而很多时候你都不知道这些错误信息因何发生；再者，反应到用户端将直接导致用户无法获取操作的结果以及失败的原因。 以下15 条异常处理的原则来自国外的博客： 1.不用使用异常来管理业务逻辑，应该使用条件语句。如果一个控制逻辑可通过 if-else 语句来简单完成的，那就不用使用异常，因为异常会降低代码的可读性和性能，例如一些null 的判断逻辑、除0的控制等等； 2.异常的名字必须清晰而且有具体的意思，表示异常发生的问题，例如 FileNotFoundException 就很清晰直观 3.当方法判断出错该返回时应该抛出异常，而不是返回一些错误值，因为错误值难以 理解而且不够直观，例如抛出FileNotFoundException 异常，而不是返回-1 或者-2 之类的错误值。 4.应该捕获指定的异常，而不是catch(Exception e) 了事，这对性能、代码的可读 性以及诸多方面都有好处 5.Null 的判断逻辑并不是一成不变的，当方法允许返回null 的时候使用if-else 控 制逻辑，否则就抛出NullPointerException 6.尽量不要二次抛出异常，如果非得这么做的话，抛出同一个异常示例，而不是重新 构建一个异常对象，这对性能是有帮助的，而且外层调用者可获取真实的异常信息
7.定义你自己的异常类层次，例如UserException 和SystemException 分别代表 用户级别的异常信息和系统级别的异常信息，而其他的异常在这两个基类上进行扩展 8.明确的使用不同的异常类型： Fatal: System crash states. Error: Lack of requirement. Warn: Not an error but error probability. Info: Info for user. Debug: Info for developer. 9.不要仅仅捕获异常而不做任何处理，不便于将来维护 10.不要多次重复记录同一个异常，这可以让我们清晰的了解异常发生的位置 11.请使用finally 来释放一些打开的资源，例如打开的文件、数据库连接等等 12.大部分情况下不建议在循环中进行异常处理，应该在循环外对异常进行捕获处理 13.异常的粒度很重要，应该为一个基本操作定义一个try-catch 块，不要为了简便， 将几百行代码放到一个try-catch 块中 14.为你的异常生成足够的文档说明，至少是JavaDoc 15.为每个异常消息定义一个数值，这对好的文档来说是非常重要的。 你有其他的补充吗？请不吝赐教。