声明:本文档仅为个人学习过程中顺手翻译之作,方便开发的同胞借鉴参考。如有觉得译的不好不到位的地方,欢迎指正,将及时做出更正
|
Cup *cup = [[Cup alloc] init]; |
|
@try { |
[cup fill]; |
} |
@catch (NSException *exception) { |
NSLog(@"main: Caught %@: %@", [exception name], [exception reason]); |
} |
@finally { |
[cup release]; |
} |
要捕获 @try{}
块中抛出的异常, 我们会使用一个或者多个 @catch{}
块紧跟在 @try{}
块后面.
@catch{}
块 对异常的捕获应该先细后粗,即是说先捕获特定的异常,再使用一些泛些的异常类型。这样做的好处是你可以为异常的处理进行分组处理,就像10-1中那样。
10-1
@try { |
... |
} |
@catch (CustomException *ce) { // 1 |
... |
} |
@catch (NSException *ne) { // 2 |
// Perform processing necessary at this level. |
... |
|
} |
@catch (id ue) { |
... |
} |
@finally { // 3 |
// Perform processing necessary whether an exception occurred or not. |
... |
} |
下面阐述了捕获异常时通常采用的捕获顺序:
优先捕获特定的需要处理的异常类型.
捕获一些较泛的异常类型
执行一些清理进程,无论异常是否发生
要抛出一个异常,你必须提供一些必要的信息,例如异常的名字以及为什么要抛出这个异常
NSException *exception = [NSException exceptionWithName: @"HotTeaException" |
reason: @"The tea is too hot" |
userInfo: nil]; |
@throw exception; |
重要: 在许多环境中,异常的使用都很常见。例如,你可能会抛出一个异常来提示一个例程无法正常执行—例如当文件缺失或者数据转型错误。在Objective-C 中异常是比较消耗资源的。对于平常的流程控制,或者简单的错误提示,你就不应该去使用异常,而是使用方法或者函数的返回值来提示是否有异常发生,并在一个错误对象中提供相关错误信息。参见 Error Handling Programming Guide.
@catch{}
块中, 你可以使用 @throw
指令(不需要提供理由)再次抛出你捕获到的异常。这种情况下省去理由会让你的代码更具可读性。
没人限制你必须抛出 NSException
对象. 你可以抛出任何 Objective-C 的对象来作为异常对象. NSException
类提供了可以在异常处理提供帮助的方法,但如果愿意你可以实现你自己带方法。你还可以继承 NSException
来实现特定的异常类型,例如文件系统异常或者通信异常。
英文原文:点击打开链接
The Objective-C language has an exception-handling syntax similar to that of Java and C++. By using
this syntax with the NSException
, NSError
,
or custom classes, you can add robust error-handling to your programs. This chapter provides a summary of exception syntax and handling; for more details, see Exception
Programming Topics.
Using GNU Compiler Collection (GCC) version 3.3 and later, Objective-C provides language-level support for exception handling. To turn on support for these features,
use the -fobjc-exceptions
switch of the GNU Compiler Collection (GCC) version 3.3 and later. (Note that this switch renders the application runnable only in Mac OS X v10.3
and later because runtime support
for exception handling and synchronization is not present in earlier versions of the software.)
An exception is a special condition that interrupts the normal flow of program execution. There are a variety of reasons why an exception may be generated (exceptions are typically said to be raised or thrown), by hardware as well as software. Examples include arithmetical errors such as division by zero, underflow or overflow, calling undefined instructions (such as attempting to invoke an unimplemented method), and attempting to access a collection element out of bounds.
Objective-C exception support involves four compiler directives: @try
, @catch
, @throw
,
and @finally
:
Code that can potentially throw an exception is enclosed in a @try{}
block.
A @catch{}
block
contains exception-handling logic for exceptions thrown in a @try{}
block.
You can have multiple @catch{}
blocks to catch different types of exception. (For a code example, see “Catching
Different Types of Exception.”)
You use the @throw
directive
to throw an exception, which is essentially an Objective-C object. You typically use an NSException
object,
but you are not required to.
A @finally{}
block
contains code that must be executed whether an exception is thrown or not.
This example depicts a simple exception-handling algorithm:
Cup *cup = [[Cup alloc] init]; |
|
@try { |
[cup fill]; |
} |
@catch (NSException *exception) { |
NSLog(@"main: Caught %@: %@", [exception name], [exception reason]); |
} |
@finally { |
[cup release]; |
} |
To catch an exception thrown in a @try{}
block, use one or more @catch{}
blocks
following the @try{}
block. The @catch{}
blocks should be ordered from most-specific to
least-specific. That way you can tailor the processing of exceptions as groups, as shown in Listing 10-1.
Listing 10-1 An exception handler
@try { |
... |
} |
@catch (CustomException *ce) { // 1 |
... |
} |
@catch (NSException *ne) { // 2 |
// Perform processing necessary at this level. |
... |
|
} |
@catch (id ue) { |
... |
} |
@finally { // 3 |
// Perform processing necessary whether an exception occurred or not. |
... |
} |
The following list describes the numbered code lines:
Catches the most specific exception type.
Catches a more general exception type.
Performs any clean-up processing that must always be performed, whether exceptions were thrown or not.
To throw an exception, you must instantiate an object with the appropriate information, such as the exception name and the reason it was thrown.
NSException *exception = [NSException exceptionWithName: @"HotTeaException" |
reason: @"The tea is too hot" |
userInfo: nil]; |
@throw exception; |
Important In many environments, use of exceptions is fairly commonplace. For example, you might throw an exception to signal that a routine could not execute normally—such as when a file is missing or data could not be parsed correctly. Exceptions are resource-intensive in Objective-C. You should not use exceptions for general flow-control, or simply to signify errors. Instead you should use the return value of a method or function to indicate that an error has occurred, and provide information about the problem in an error object. For more information, see Error Handling Programming Guide.
Inside a @catch{}
block, you can rethrow the caught exception using the @throw
directive
without providing an argument. Leaving out the argument in this case can help make your code more readable.
You are not limited to throwing NSException
objects. You can throw any Objective-C object as an exception object. The NSException
class
provides methods that help in exception processing, but you can implement your own if you so desire. You can also subclass NSException
to
implement specialized types of exceptions, such as file-system exceptions or communications exceptions.
|
来自: 现在决定明天 > 《Objective-c官方文档》