An Exception
exception is an object that is generated at runtime to describe a problem encountered during the execution of a program. Some causes for an exception are integer division-by-zero, array index out-of-bounds, illegal cast, interrupted I/O operation, missing file, incorrect number format etc.
Exception Handling
Java exception handling enables a program to catch all exceptions, or to catch all exceptions of a certain type, or to catch all exceptions of related types. This makes programs more robust by reducing the likelihood that errors will not be caught by a program.
Exception Handling
Exception handling is provided to enable programs to catch and handle errors rather than letting them occur and suffering the consequences. Exception handling is designed for dealing with synchronous errors such as an attempt to divide by zero.
Exception Handling
Exception handling is not designed to deal with asynchronous events such as disk I/O completions, network message arrivals, mouse clicks, keystrokes and the like; These are best handled through other means, such as Java event listeners.
When Exception Handling Should Be Used
To process only exceptional situation where a method is unable to complete its task for reasons it cannot control. To process exceptions form program components that are not geared to handling those exceptions directly.
When Exception Handling Should Be Used
To process exceptions from software components such as methods, libraries and classes that are likely to be widely used, and where those components cannot handle their own exceptions. On large projects to handle exceptions in a uniform manner project wide.
An Example of Exception Handling
Let us do the first example............ The output from this program is: Exception in thread "main" java.lang.ArithmeticException: / by zero at DivideByZero.d(DivideByZero.java:21) at DivideByZero.c(DivideByZero.java:15) at DivideByZero.b(DivideByZero.java:11) at DivideByZero.a(DivideByZero.java:7) at DivideByZero.main(DivideByZero.java:3)
Example
You can see that an arithmetic exception object was generated at line 21. It was handled by the default exception handling mechanism. Information about the exception is displayed, and execution of the application is stopped.
catch, try and finally block
The Java language allows you to handle exceptions that occur during execution of a program. This is done by using the following syntax:
catch, try and finally block
Try{ //try block } Catch(Exception Type1 param1){ //exception handling block} ... catch(Exception TypeN param3){ //exception handling block } Finally{ //finally block }
catch, try and finally block
The try statement contains a block of statements enclosed by braces. This is the code you want to monitor for exceptions. If a problem occurs during its execution, an exception is thrown.
catch, try and finally block
Immediately following the try block is a sequence of catch blocks. Each of these begins with the catch keyword. An argument is passed to each catch block. That argument is the exception object that contains information about the problem.
catch, try and finally block
If a problem occurs during execution of the try block, the java Virtual Machine immediately stops executing the try block and looks for a catch block that can process that type of exception. Any remaining statements in the try block are not executed.
catch, try and finally block
The search begins at the first catch block. If the type of the exception object matches the type of the catch block parameter, those statements are executed. Otherwise, the remaining catch clauses are examined in sequence for a type match.
catch, and try finally block
One of the biggest advantages of the Java exception handling mechanism is that it allows you to write software that is better organized and easier to understand. You no longer need to distribute code to check and handle errors throughout your program. Instead , a try block can be written and , if problems occur during its execution, control proceeds in a well-defined manner to the appropriate catch block.
catch, try and finally block
When a catch block completes execution , control passes to the statements in the finally block. The Java compiler ensures that the finally block is executed in all circumstances. When a try block completes without problems, the finally block executes. Even if a return statement is included in a try block, ther compiler ensures that the finally block is executed before the current method returns.
catch, try and finally block
The finally block is optional. Each try block must have at least one catch or finally block. Oterwise a compiler error occurs.
Example 2
The example Divider.java illustrates the flow of control in a program with exception handling. The application accepts two strings in integer format as its command-line arguments.
Example 2
The first number is divided by the second number and the result is displayed. There are catch blocks to handle different types of exceptions that can occur.
Example 2
If a division-by-zero is attempted, an ArithmeticException occurs. An ArrayIndexOutOfBoundsException occurs if one or both of the command-line arguments is missing.
Example 2
If an argument is not formatted as an integer, a NumberFormatException occurs. Try executing this program with these different conditions and observe the results.
Example2
Notice that the finally block always executes. Also observe that the call to println( ) after the division never executes if an exception occurs.
Throwing an Exception
The Java language has many exceptions that it can throw: From the Java Virtual Machine itself when a runtime error occurs. Java developers may also throw exceptions from their own methods Additionally, you can write your own exception classes
Throwing an Exception
In the previous examples,...