Exception Types

Exceptions are two kinds:

those are: 1) Checked Exceptions

                   2)Unchecked Exceptions

                            Under Unchecked Exceptions there are two kinds are there :
                                

1. Errors

                                   2. Runtime Exceptions

- Exceptions which are detected by Java Compiler at compile time is called Checked Exceptions.These are exceptional conditions that a well-written application should anticipate and recover from.

Example : suppose an application prompts a user for an input file name, then opens the file by passing the name to the constructor for java.io.FileReader.

- Normally, the user provides the name of an existing, readable file, so the construction of the FileReader object succeeds, and the execution of the application proceeds normally.
But sometimes the user supplies the name of a nonexistent file, and the constructor throws java.io.FileNotFoundException. A well-written program will catch this Exception and notify the user of the mistake, possibly prompting for a corrected file name.

- All Exceptions are Checked Exceptions, except for those indicated by Error, RuntimeException, and their subclasses.

Unchecked Exceptions:

 Errors and Runtime Exceptions are collectively known as Unchecked Exceptions.

Errors : These are exceptional conditions that are external to the application, and that the application usually cannot anticipate or recover from.

Example : An application successfully opens a file for input, but is unable to read the file because of a hardware or system malfunction. The unsuccessful read will throw java.io.IOError. An application might choose to catch this exception, in order to notify the user of the problem.

- Errors are those exceptions indicated by Error and its SubClasses.

Runtime Exceptions : These are exceptional conditions that are internal to the application, and that the application usually cannot anticipate or recover from. These usually indicate programming bugs, such as logic errors or improper use of an API.

- Runtime Exceptions are those indicated by RuntimeException and its SubClasses.

Example : An application that passes a file name to the constructor for FileReader. If a logic error causes a null to be passed to the constructor, the constructor will throwNullPointerException. The application can catch this exception, but it probably makes more sense to eliminate the bug that caused the exception to occur.

An Exception Thrown By a method without Handeling and Handling

Sometimes, it's appropriate for code to catch Exceptions that can occur within it. In other cases, however, it's better to let a method further up the call stack Handle the Exception. In that situation it's better to throw an Exception without handle (catch) it.

- It's done by Throws clause

Throws clause : It comprises the throws keyword followed by a comma separated list of all the Exceptions thrown by that method. The clause goes after the method name and argument list and before the brace that defines the scope of the method.

Note : we can use Throws clause only for Checked Exceptions. i.e., like IOExcepion, FileNotFoundException.

Example :

public void writeList() throws IOException { ---- }

Throwing an Exception:


Creating an Exception Object and handing it to the Runtime System is called Throwing an Exception.

We can catch and handle Exceptions by using these three Exception Handler Components

1. Try Block
2. Catch Block
3. Finally Block

Chained Exception in Java

An application often responds to an Exception by throwing another Exception. In effect, the first Exception causes the second Exception. It can be very helpful to know when oneException causes another.

- Chained Exceptions help the programmer do this.

The following are the methods and constructors in Throwable that support Chained Exceptions.

Throwable getCause()
Throwable initCause(Throwable)
Throwable(String, Throwable)
Throwable(Throwable)

The Throwable argument to initCause and the Throwable constructors is the Exception that caused the current Exception. getCause returns the Exception that caused the currentException, and initCause returns the current Exception.

Example :


try {

} catch (IOException e) {
throw new SampleException("Other IOException", e);
}

In this example, when an IOException is caught, a new SampleException Exception is created with the original cause attached and the chain of Exceptions is thrown up to the next higher level Exception handler.