exception in java
TRANSCRIPT
Exception in Java
Exception are such anomalous conditions (or typically an event) which changes the normal flow of execution of a program. Exceptions are used for signaling erroneous (exceptional) conditions which occur during the run time processing. Exceptions may occur in any programming language.
Occurrence of any kind of exception in java applications may result in an abrupt termination of the JVM or simply the JVM crashes which leaves the user unaware of the causes of such anomalous conditions. However Java provides mechanisms to handle such situations through its superb exception handling mechanism. The Java programming language usesException classes to handle such erroneous conditions and exceptional events.
Exception ObjectIn java, when any kind of abnormal conditions occurs with in a method then the exceptions are thrown in form of Exception Object i.e. the normal program control flow is stopped and an exception object is created to handle that exceptional condition. The method creates an objectand hands it over to the runtime system. Basically, all the information about the error or any unusual condition is stored in this type of object in the form of a stack. This object created is called an exception object the process is termed as throwing an exception. The mechanism of handling an exception is called catching an exception or handling an Exception or simply Exception handling. As we have known that after throwing an exception it is handed off to the runtime system that finds a possible method from an ordered list of methods to handle it. The list of this type of methods is known as the call stackAs we have already learned that, what are the exceptions. Point to be remember here is that exceptions are not errors rather they are some abnormal conditions that aren't necessarily errors. Therefore, the process of detecting the exceptions and responding to them as well is known asException handling.
Following are the advantages of Exception-handling in Java:
Exception provides the means to separate the details of what to do when something out of the ordinary happens from the main logic of a program.
One of the significance of this mechanism is that it throws an exception whenever a calling method encounters an error providing that the calling method takes care of that error.
With the help of this mechanism the working code and the error-handling code can be disintegrated. It also gives us the scope of organizing and differentiating between different error types using a separate block of codes. This is done with the help of try-catch blocks.
Furthermore the errors can be propagated up the method call stack i.e. problems occurring at the lower level in the chain can be handled by the methods higher up the call chain .
Sample CodeThe basic syntax to handle an Exception looks like this:
String myException(){try{return myMethod();}catch ( IOException e ){return null;}}
There are three types of Exceptions:
1. Checked Exceptions - These are the exceptions which occur during the compile time of the program. The compiler checks at the compile time that whether the program contains handlers for checked
exceptions or not. These exceptions do not extendRuntimeException class and must be handled to avoid a compile-time error by the programmer. These exceptions extend the java.lang.Exception class These exceptional conditions should be anticipated and recovered by an application. Furthermore Checked exceptions are required to be caught. Remember that all the exceptions are checked exceptions unless and until those indicated by Error, RuntimeException or their subclasses.
For example if you call the readLine() method on a BufferedReader object then theIOException may occur or if you want to build a program that could read a file with a specific name then you would be prompted to input a file name by the application. Then it passes the name to the constructor for java.io.FileReader and opens the file. However if you do not provide the name of any existing file then the constructor throwsjava.io.FileNotFoundException which abrupt the application to succeed. Hence this exception will be caught by a well-written application and will also prompt to correct the file name.
Here is the list of checked exceptions.
NoSuchFieldException
InstantiationException
IllegalAccessException
ClassNotFoundException
NoSuchMethodException
CloneNotSupportedException
InterruptedException
2. Unchecked Exceptions - Unchecked exceptions are the exceptions which occur during the runtime of the program. Unchecked exceptions are internal to the application and extend the java.lang.RuntimeException that is inherited from java.lang.Exceptionclass. These exceptions cannot be anticipated and recovered like programming bugs, such as logic errors
or improper use of an API. These type of exceptions are also calledRuntime exceptions that are usually caused by data errors, like arithmetic overflow, divide by zero etc.
Lets take the same file name example as described earlier. In that example the file name is passed to the constructor for FileReader. However, the constructor will throwNullPointerException if a logic error causes a null to be passed to the constructor. Well in this case the exception could be caught by the application but it would rather try to eliminate the bug due to which the exception has occurred. You must have encountered the most common exception in your program i.e. the ArithmeticException. I am sure you must be familiar with the reason of its occurrence that is when something tries to divide by zero. Similarly when an instance data member or method of a reference variable is to be accessed that hasn't yet referenced an object throws NullPointerException.
Here is the list of unchecked exceptions.
IndexOutOfBoundsException
ArrayIndexOutOfBoundsException
ClassCastException
ArithmeticException
NullPointerException
IllegalStateException
SecurityException
3.
4. Error - The errors in java are external to the application. These are the exceptional conditions that could not be usually anticipated by the application and also could not be recovered from. Error exceptions belong to Error and its subclasses are not subject to the catch or Specify requirement. Suppose a file is successfully opened by an application for input but due to some system malfunction could not be able to read that file then thejava.io.IOError would be thrown. This error will cause the program to terminate but if an application wants then the error might be caught. An Error indicates serious problems
that a reasonable application should not try to catch. Most such errors are abnormal conditions.
Hence we conclude that Errors and runtime exceptions are together called as unchecked exceptions.
Exception Classes
The hierarchy of exception classes commence from Throwable class which is the base class for an entire family of exception classes, declared in java.langpackage as java.lang.Throwable. A throwable contains a snapshot of the execution stack at the time it was created and also a message string that gives more information about the error. This class can be instantiated and thrown by the program. The throwable class is further divided into two subclasses :-
1. Exceptions - Exceptions are thrown if any kind of unusual condition occurs that can be caught. Sometimes it also happens that the exception could not be caught and the program may get terminated. Remember that they are a member of Exception family and can be type of Checked or Unchecked exception.
2. Errors - When any kind of serious problem occurs which could not be handled easily likeOutOfMemoryError then an error is thrown. Well, errors are not something which is thrown by you rather they are thrown by the Java API or by the Java virtual machine itself i.e. only the exceptions are thrown by your code and not the errors. Also Remember that they are a member of Error family.
The exception classes can be explained as well seeing the exception hierarchy structure:
The java.lang package defines several classes and exceptions. Some of these classes are not checked while some other classes are checked.
EXCEPTIONSDESCRIPTION
CHECKED
UNCHECKED
ArithmeticExceptionArithmetic errors such as a divide by zero
- YES
ArrayIndexOutOfBoundsException
Arrays index is not within array.length
- YES
ClassNotFoundExceptionRelated Class not found
YES -
IOExceptionInputOuput field not found
YES -
IllegalArgumentException
Illegal argument when calling a method
- YES
InterruptedException
One thread has been interrupted by another thread
YES -
NoSuchMethodExceptionNonexistent method
YES -
NullPointerExceptionInvalid use of null reference
- YES
NumberFormatExceptionInvalid string for conversion to number
- YES
As you have come to know that exceptions are Objects that means an object is thrown when you throw an exception. Moreover only those objects could be thrown whose classes are derived from Throwable.
It is interesting to note here that the objects of your own design could also be thrown provided that they should be the subclass of some member of the Throwable family. Also the throwable classes which are defined by you must extend Exception class.
It depends upon the situation that whether to use an existing exception class from java.lang or create any of your own. Such as IllegalArgumentException, a subclass of RuntimeExceptionin java.lang can be thrown if any method with an invalid argument is thrown by you. On the other hand you need not to worry if you wish to impart some more information about any unusual condition other than a class from java.lang because it will be indicated by the class of exception object itself.
For example, if a thrown exception object has class IllegalArgumentException, that indicates someone passed an illegal argument to a method. Sometimes you will want to indicate that a method encountered an abnormal condition that isn't represented by a class in the Throwable family of java.lang.For instance, lets tweak an example below that demonstrates the exceptional conditions that might occur while driving a car.
// In Source Packet in file except/ex1/SpeedException.javaclass SpeedException extends Exception {}// In Source Packet in file except/ex1/VeryFastException.javaclass VeryFastException extends SpeedException {}// In Source Packet in file except/ex1/VerySlowException.javaclass VerySlowException extends SpeedException {}
Lets tweak the diagram below.
It is clear from the above program that there is something abnormal with the speed of the car i.e. either it is very fast or it is very slow. Hence two
exceptions are thrown by the program -VeryFastException and VerySlowException. To be more precise
the SpeedException family specifies three new exceptions thrown by the program which indicate some abnormal conditions. That is the
SpeedException specifies that there is something unusual with the speed; VeryFastException and VerySlowException specifies the abnormal
conditions of the speed.
NOTE: The SpeedException extends Exception only and not the Throwable or Error class.
Java Catching and Handling Exceptions
The various keywords for handling exceptions are below.
try
catch
finally
throw
throws
The three exception handler components are used to catch and handle the exceptions. These are try, catch and finally clause. The mechanism to catch an exception in Java is to use try and catch block. Every catch block can handle only one type of exception however you can use more than one catch clause in a single try block. Simply a statement is surrounded by the try block that may cause the exception to occur. Then the try block is followed by the catch block. And if the exception occurs then this catch block specifies a code that should be executed.
Using try and catch:-
The syntax for the usage of try, catch and finally block is given below.
try{ ……… ………}catch(<exceptionclass1> <obj1>){ ……… ………}finally{ ……… ………}
For using an exception handler in an application, the first step we need to do is to enclose the code that is likely to generate an exception inside a try block. If an exception occurs in the try block then it is handled by the exception handler associated with it. For doing this we need to have one or more catch blocks after the try block, where each catch block acts as an exception handler and can handle the type of exception indicated by its arguments. Lets have a look at the example which shows the implementation of the try, catch and finally block. Here we have used "fis = new FileInputStream (new File (args[0]));" which throws an exception if we write a name of a file which doesn't exist as shown in the output.
import java.io.*;
class Test{public static void main(String args[])throws IOException {FileInputStream fis=null;try{fis = new FileInputStream (new File (args[0]));}catch (FileNotFoundException e){System.out.println("File not found!");}finally{fis.close();
}}}
Output of program:
C:\Roseindia\vinod\Exception>javac Test.java
C:\Roseindia\vinod\Exception>java TestFile not found!
Download this example
The code which is to be executed in a try block indicates that it will throw an exception. And if the exception occurs then the runtime system checks whether the exception thrown by try block matches to the one in catch clause or not. If yes, then the code within the catch clause gets executed which actually handles the exception.
Using final: It is always a good practice to use finally clause after the try and catch block because the finally block always executes even if an unexpected exception occurs i.e. whether or not an exception thrown. The finally block executes if and only if the try block exits. Other than exception handling the finally clause helps you in avoiding any cleanup code accidentally bypassed by a return etc. The statements within the finally block gets executed by the the runtime system without taking care of what happens within the try block.
There are two steps to use the finally clause:
First, you need to enclose the code in a try block that has multiple exit points.
Secondly after the try block exits place the code that must be executed in a finally clause.
Same way we have used the finally block which will execute after the try and catch block.
import java.io.*;
class Test{public static void main(String args[]){FileInputStream fis=null;try {
fis = new FileInputStream (new File (args[0]));int ch;while ((ch = fis.read()) != -1){System.out.print ((char) ch);}}catch (FileNotFoundException e){System.out.println("File not found!");}catch (IOException e){System.out.println("Unable to read file!");}finally{System.out.println();System.out.println("In finally.");try{if(fis!=null){fis.close();}}catch (IOException ioe){System.out.println("In finally.");}}}}
Output of program:
C:\Roseindia\vinod\Exception>javac Test.java
C:\Roseindia\vinod\Exception>java Test abcFile not found!
In finally.
Download this example
Using throws: The other way to handle an exception is using the throws clause. When you call a method from the java API that throws a checked exception, you must either throw the exception or catch it. If you decide that you can't handle the exception properly, then the exception can be declared to the method header using the throws keyword followed by the class name of the exception.
You might have come across the throws IOException clause in the method header. For exampleSystem.in.read() will give a compile error for IOException. Add the throws clause to the surrounding method to pass the error up to the next level (or else write your own catch/try handler). This clause is placed between the parameter list and the starting of the opening brace of the method. We use this clause when we know that a particular exception may occur. Then instead of terminating the program the compiler throws the exception.
While the throw keyword (note the singular form) is used to force an exception. It can also pass a custom message to your exception handling module. for example:-
throw new FileNotFoundException("Could not find books.txt");
The syntax for coding the throws clause of a method is as:-
method declaration throws Exception1,[Exception2] .......{ }
Likewise we have used throws clause to the method header as "throws FileNotFoundException,IOException " which throws an exception as shown in the output.
import java.io.*;
class Test3{public static void main(String args[]) throws FileNotFoundException,IOException {FileInputStream fis=null;fis = new FileInputStream (new File (args[0]));int ch;while ((ch = fis.read()) != -1){System.out.print ((char) ch);}fis.close();}}
Output of program:
C:\Roseindia\vinod\Exception>javac Test3.java
C:\Roseindia\vinod\Exception>java Test3Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0at Test3.main(Test3.java:6)
How to Throw Exceptions in Java
Before catching an exception it is must to be thrown first. This means that there should be a code somewhere in the program that could catch the exception. We use throw statement to throw an exception or simply use the throw keyword with an object reference to throw an exception. A single argument is required by the throw statement i.e. a throwable object. As mentioned earlier Throwable objects are instances of any subclass of the Throwable class.
throw new VeryFastException();
Note: The reference should be of type Throwable or one of its subclasses.
For instance the example below shows how to throw an exception. Here we are trying to divide a number by zero so we have thrown an exception here as "throw new MyException("can't be divided by zero");"
class MyException extends Exception {public MyException(String msg){super(msg);}}
public class Test {
static int divide(int first,int second) throws MyException{ if(second==0) throw new MyException("can't be divided by zero");return first/second; }
public static void main(String[] args) { try {System.out.println(divide(4,0)); }catch (MyException exc) {exc.printStackTrace(); } }}
Output of program:
C:\Roseindia\vinod\
Exception>javac Test.java
C:\Roseindia\vinod\Exception>java TestMyException: can't be divided by zeroat Test.divide(Test.java:10)at Test.main(Test.java:15)
C:\Roseindia\vinod\Exception>
Download this example
Difference between throw and throws keywords
Whenever we want to force an exception then we use throw keyword. the throw keyword (note the singular form) is used to force an exception. It can also pass a custom message to your exception handling module. Moreover throw keyword can also be used to pass a custom message to the exception handling module i.e. the message which we want to be printed. For instance in the above example we have used -
throw new MyException ("can't be divided by zero");
Whereas when we know that a particular exception may be thrown or to pass a possible exception then we use throws keyword. Point to note here is that the Java compiler very well knows about the exceptions thrown by some methods so it insists us to handle them. We can also use throws clause on the surrounding method instead of try and catch exception handler. For instance in the above given program we have used the following clause which will pass the error up to the next level -
static int divide(int first,int second) throws MyException{
Handling Multiple Catch Clauses
So far we have seen how to use a single catch block, now we will see how to use more than one catch blocks in a single try block.In java when we handle the exceptions then we can have multiple catch blocks for a particular try block to handle many different kind of exceptions that may be generated while running the program i.e. you can use more than one catch clause in a single try block however every catch block can handle only one type of
exception. this mechanism is necessary when the try block has statement that raise different type of exceptions.
The syntax for using this clause is given below:-
try{………………}catch(<exceptionclass_1> <obj1>){//statements to handle the exception }
catch(<exceptionclass_2> <obj2>){//statements to handle the exception }catch(<exceptionclass_N> <objN>){//statements to handle the exception }
When an exception is thrown, normal execution is suspended. The runtime system proceeds to find a matching catch block that can handle the exception. If no handler is found, then the exception is dealt with by the default exception handler at the top level. Lets see an example given below which shows the implementation of multiple catch blocks for a single try block.
public class Multi_Catch{ public static void main (String args[]) { int array[]={20,10,30}; int num1=15,num2=0; int res=0;
try { res = num1/num2; System.out.println("The result is" +res);
for(int ct =2;ct >=0; ct--) { System.out.println("The value of array are" +array[ct]); }
} catch (ArrayIndexOutOfBoundsException e) { System.out.println("Error…. Array is out of Bounds"); }
catch (ArithmeticException e) { System.out.println ("Can't be divided by Zero"); }
} }
Output of the program:
C:\Roseindia\>javac Multi_Catch.java
C:\Roseindia\>java Multi_Catch
Can't be divided by Zero
In this example we have used two catch clause catching the exceptionArrayIndexOutOfBoundsException and ArithmeticException in which the statements that may raise exception are kept under the try block. When the program is executed, an exception will be raised. Now that time the first catch block is skipped and the second catch block handles the error.
Download this program
Lets have an another output, in which the second catch block is skipped and the first catch block handles the error.
public class Multi_Catch1{
public static void main (String args[]) { int array[]=new int [5]; int num1=15,num2=2; int res=0;
try { res = num1/num2; System.out.println("The result is" +res);
for(int ct =0;ct <=5; ct++) { array[ct] = ct * ct ; }
} catch (ArrayIndexOutOfBoundsException e) { System.out.println("Assigning the array beyond the upper bound"); }
catch (ArithmeticException e) { System.out.println ("Can't be divided by Zero"); }
} }
Output of the program:
C:\Roseindia\>javac Multi_Catch.java
C:\Roseindia\>java Multi_Catch
Assigning the array beyond the upper bound
Download this example
Handling the Unreachable Code Problem
The multiple catch blocks can generate unreachable code error i.e. if the first catch block contains the Exception class object then the subsequent catch blocks are never executed. This is known as Unreachable code problem. To avoid this, the last catch block in multiple catch blocks must contain the generic class object that is called the Exception class. This exception class being the super class of all the exception classes and is capable of catching any types of exception. The generic Exception class can also be used with multiple catch blocks.
Take a look at the following example:
public class Generic_Excep{ public static void main (String args[]) { String str = "Exception" ; int len=0; try { StringBuffer sbuf = new StringBuffer(str); len = str.length() ; for(int ct=len;ct>=0;ct--) { System.out.print(sbuf.charAt(ct)); } } catch(Exception e) { System.out.println("Error...."+e); } } }
Output of the program:
C:\Roseindia\>javac Generic_Excep.java
C:\Roseindia\>java Generic_Excep
Error....java.lang.StringIndexO
utOfBoundsException:String index out of range: 9
In this example we didn't specify that which one exception may occur during the execution of program but here we are trying to access the value of an array that is out of bound still we don't need to worry about handle the exception because we have used the Exception class that is responsible to handle any type of exception.
Nested Try-Catch Blocks
In Java we can have nested try and catchblocks. It means that, a try statement can be inside the block of another try. If an inner try statement does not have a matching catch statement for a particular exception, the control is transferred to the next try statement’s catch handlers that are expected for a matching catch statement. This continues until one of the catch statements succeeds, or until all of the nested try statements are done in. If no one catch statements match, then the Java run-time system will handle the exception.
The syntax of nested try-catch blocks is given below:
try { try { // ... } catch (Exception1 e) { //statements to handle the exception } } catch (Exception 2 e2) { //statements to handle the exception }
Lets have an example that uses the nested try-catch blocks
import java.io.*;public class NestedTry{
public static void main (String args[])throws IOException { int num=2,res=0; try{ FileInputStream fis=null; fis = new FileInputStream (new File (args[0])); try{ res=num/0; System.out.println("The result is"+res); } catch(ArithmeticException e){ System.out.println("divided by Zero"); } } catch (FileNotFoundException e){ System.out.println("File not found!"); } catch(ArrayIndexOutOfBoundsException e){ System.out.println("Array index is Out of bound! Argument required"); } catch(Exception e){ System.out.println("Error.."+e); }}}
Output of the program:
C:\Roseindia\>javac NestedTry.java
C:\Roseindia\>java NestedTry
Array index is Out of bound! Argument required
In this given example we have implemented nested try-catch blocks concept where an inner try block is kept with in an outer try block, that's catch handler will handle the arithmetic exception. But before that an ArrayIndexOutOfBoundsException will be raised, if a file name is not passed as an argument while running the program. Now lets see, what will be the output if we pass the file name student as an argument.
C:\Roseindia\>javac NestedTry.java
C:\Roseindia\>java NestedTry student.txt
File not found!
If the outer try block's statements run successfully then the inner try will raise an ArithmeticException as:
C:\Roseindia\>javac NestedTry.java
C:\Roseindia\>java NestedTry student.txt
divided by Zero
Catching Normal Exceptions
The exceptions that are generated by methods are referred to as normal exceptions. We have already learned that to catch an exception we use try and catch block.
try {myTestException();}catch(ExceptionType1 e) {System.out.println(e.getMessage());}catch(Exceptiontype2 e) {System.out.println(e.getMessage());}
The code above shows how to handle multiple exceptions. We have used myTestException();method here which generates two different types of exceptions handled by separate catch clauses in a unique manner. By comparing the exception type, the catch clauses are examined whenever an exception occurs in a try block A match will occur whenever the type of exception is same as that in catch clause or same as the subclass in the catch clause. Hence due to this multilevel catch handlers can be provided which are based on more derived exception types. Lets see one more example:
FileInputStream fis=null; try{fis = new FileInputStream (new File (args[0]));
}catch (FileNotFoundException e){System.out.println("File not found!"); + e.getMessage());}
Here we have created a file input stream and the constructor which takes a file name to read from will throw FileNotFoundException if the file couldn't be found. Within a try block an object is created that handles the exception FileNotFoundException in a catch block as the constructor is capable of throwing this exception.
Catching Runtime Exceptions
The exceptions which are not easily traced are known as Runtime Exceptions. For instance,
try {int x = 50;for (int i = 15; i >= 0; i--)System.out.println(x / i);}catch(ArithmeticException e) {System.out.println(e.getMessage());}
The above code displays a for loop trying to divide a number by zero in its last iteration which would result in runtime exception. We have used try block to handle this exception and a corresponding handler by means of a catch clause. And if we won't handle the exception the program will end up with the termination.
The disadvantage in handling the runtime exception is that we need to put the doubtful code inside a try block. This approach sometimes causes a mess so its always better to avoid the problems which land you up with the troubles.
Making Custom (User Define Exceptions)So far you would have been known, how to be handled the exceptions in java =======
So far you would have been known, how to be handled the exceptions in java >>>>>>> 1.3 that are thrown by the Java API but sometimes you may occasionally need to throw your own exception i.e. if you encounter a
situation where none of those exception describe your exception accurately or if you can't find the appropriate exception in the Java API, you can code a class that defines an exception that is more appropriate and that mechanism of handling exception is calledCustom or User Defined Exception.
In Java API all exception classes have two type of constructor. First is called default constructor that doesn't accept any arguments. Another constructor accepts a string argument that provides the additional information about the exception. So in that way the Custom exception behaves like the rest of the exception classes in Java API.
There are two primary use cases for a custom exception.
your code can simply throw the custom exception when something goes wrong.
You can wrap an exception that provides extra information by adding your own message.
The code of a Custom exception:
public class ExceptionClassName extends Exception{ public ExceptionClassName(){ } public ExceptionClassName(StringMessage) { super(message); } }
Lets see an example that has the implementation of User Define Exception:
import java.io.*;import java.util.*;
class MyException extends Exception{ private String nm=""; public String getMessage(String s) {
nm=s; return ("you are not permitted to enter
inside "+nm); }}
public class ExcepDemo { public static void main(String args[])throws MyException,IOException { String temp="";
try { String str="amit"; System.out.println("Enter the your name"); BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); temp=br.readLine();
if(!temp.equals(str)) throw new MyException(); else System.out.println("Welcome to Rose India"); } catch(MyException e) { System.err.println(e.getMessage(temp)); } catch(Exception e){ System.err.println(e); } } }
Output of the program:
C:\Roseindia\>javac ExcepDemo.java
C:\Roseindia\>java ExcepDemo
Enter the your name
nisha
you are not permitted to enter inside nisha
C:\Roseindia\>java ExcepDemo
Enter the your name
amit
Welcome to Rose India
In this example we have created own exception class as MyException that throws an exception and a function with argument as getMessage that shows an exception message, if the user tries to enter the another name which doesn't match with a particular predefined name. After throwing exception the control will be transferred in the catch block to handle the exception where the function is invoked to display the message included in that function.
What are Chained Exceptions in Java?
Whenever in a program the first exception causes an another exception, that is termed as Chained Exception. Java provides new functionality for chaining exceptions. Exception chaining (also known as "nesting exception") is a technique for handling the exception, which occur one after another i.e. most of the time is given by an application to response to an exception by throwing another exception. Typically the second exception is caused by the first exception. Therefore chained exceptions help the programmer to know when one exception causes another.
The constructors that support chained exceptions in Throwable class are:
Throwable initCause(Throwable)Throwable(Throwable)Throwable(String, Throwable)Throwable getCause()
The methods of the Throwable class are:
METHOD DESCRIPTION
toString()Returns the exception followed by a message string (if one exit) .
getMessage() Returns the message string of the
Throwable object.
printStackTrace()Returns the full name of the exception class and some additional information apart from the information of first two method.
getCause()Returns the exception that caused the occurrence of current exception.
initCause()Returns the current exception due to theThrowable constructors and the Throwableargument to initCause.
The syntax for using a chained exception is as follows in which a new TestException exception is created with the attached cause when an IOException is caught. Thus the chain exception is thrown to next level of exception handler.
try {} catch (IOException e) {throw new TestException("Other IOException", e);}
Lets see an example having the implementation of chained exceptions:
import java.io.*;import java.util.*;class MyException extends Exception{MyException(String msg){ super(msg); }}public class ChainExcep{ public static void main(String args[])throws MyException, IOException{ try{ int rs=10/0; }catch(Exception e){ System.err.println(e.getMessage()); System.err.println(e.getCause()); throw new MyException("Chained ArithmeticException"); } } }
Output of the Program:
C:\Roseindia\>javac ChainExcep.java
C:\Roseindia\>java javac ChainExcep
/ by zeronullException in thread "main" MyException: Chained ArithmeticExceptionat ChainExcep.main(ChainExcep.java:21)
This example has an user defined exception that throws an ArithmeticException and has been thrown under the catch handler. After throwing an exception, the handler will execute the statement of the catch block and then invoke the user defined constructor. Thus the implementation of chained exception is very helpful to the user to make a program or an application error and exception free.
Download this example
Now lets see the two different ways to generate an Exception.
1. Exceptions generated by the Java run-time system - These are the exceptions which violate the rules of the Java language and are related to some fundamental errors.
Manually generated Exceptions - These are the exceptions which are being generated manually by your code and by which some of the error
conditions are reported to the caller of a method .
How to Print a Stack Trace Message
As we have seen that java provides a method getMessage() method that is used with an object of the Exception class to print errors to debug the process. For example:
try { // ......} catch (IOException e) { // ........... System.out.println("Got an IOException: " + e.getMessage());}
Instead of this this method you can get more information about the error process if you print astack trace from the exception using the printStackTrace() method that is the method of theThrowable class and prints the stack trace to the console and provides the line numbers of statements that called the methods in the current stack.
Lets see an example that prints an exception's message.
public class PrintStack{ public static void main (String args[]){ String str = "Exception" ; int len=0; try{ StringBuffer sbuf = new StringBuffer(str); len = str.length() ; for(int ct=len;ct>=0;ct--){ System.out.print(sbuf.charAt(ct)); } } catch(Exception e) { e.printStackTrace(); } } }
Output of the program:
C:\Roseindia\>javac PrintStack.java
C:\Roseindia\>java PrintStack
java.lang.StringIndexOutOfBoundsException: String index out of range: 9at java.lang.StringBuffer.charAt(Unknown Source)at PrintStack.main(PrintStack.java:13)
Exceptions:Exception, that means exceptional errors. Actually exceptions are used for handling errors in programs that occurs during the program execution. During the program execution if any error occurs and you want to print your
own message or the system message about the error then you write the part of the program which generate the error in the try{} block and catch the errors using catch() block. Exception turns the direction of normal flow of the program control and send to the related catch() block. Error that occurs during the program execution generate a specific object which has the information about the errors occurred in the program.
In the following example code you will see that how the exception handling can be done in java program. This example reads two integer numbers for the variables a and b. If you enter any other character except number ( 0 - 9 ) then the error is caught by NumberFormatException object. After that ex.getMessage() prints the information about the error occurring causes.
Code of the program :
import java.io.*;
public class exceptionHandle{ public static void main(String[] args) throws Exception{ try{ int a, b; BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); a = Integer.parseInt(in.readLine()); b = Integer.parseInt(in.readLine()); } catch (NumberFormatException ex){ System.out.println(ex.getMessage() + " is not a numeric value."); System.exit(0); } }}
Output of this program:
C:\vinod\xml>javac exceptionHandle.java
C:\vinod\xml>java exceptionHandle
For input string: "" is not a numeric value.
An exception is an event that occurs and interrupts the normal flow of instructions. That is exceptions are objects that store the information about the occurrence of errors. When any kind of error or unusual condition occurs, these exceptions are being thrown. Any exception used to occur earlier always resulted in a program crash. However, some programming languages like java have mechanisms for handling exceptions. This is known
as catching exception in Java. The exceptions that occur in the program can be caught using try and catch block. Remember, the program will crash if the exception would not be caught. There are three types of exceptions in Java. These are -:
1. Checked Exceptions2. The error3. Runtime exception
Error and Runtime exceptions are known as unchecked exceptions. This chapter covers how to throw an exception and catch it. A detailed explanation on the types of exceptions and the advantages of the exceptions.
Basic I/O:In this section we will learn about basic input and out put operations in Java. Different kinds of sources and destinations are represented by a Stream like disk files, devices, memory arrays etc. A Stream is a sequence of data. An Input Stream is used by the program to read data from the source. Similarly, a program uses an Output stream to write data to a destination. It also supports different kinds of data including simple bytes, primitive data types, objects etc. We will learn about I/O Steams and how to use them.
Concurrency:Concurrency is generally used to perform multiple tasks simultaneously. In this section we will learn how to write applications to perform multitasking. There are two types of units of execution process and threads. Thread is the most important unit in concurrent programming. There are many processes and threads which are active in a computer system. However only one threads executes at a time even in systems that only have a single execution core.
Regular expressionThe set of strings which are based on common characteristics are shared by each string in the set. Basically, Regular expressions are are a set of strings.
This regular expression as a Java string, becomes "\\\\". That is 4 backslashes to match a single one. As in literal Java strings the backslash is an escape character. The literal string as a single backslash is denoted by "\\". In this chapter we will learn to create a syntax for regular expressions and how to use them.
Input And Output
IntroductionThe Java I/O means Java Input/Output and is a part of java.io package. This package has a InputStreamand OutputStream. Java InputStream is for reading the stream, byte stream and array of byte stream. It can be used for memory allocation. TheOutputStream is used for writing byte and array of bytes. Here, you will know several interfaces provided by the java.io package as follows:
Interfaces and Descriptions:DataInput This interface can be used for reading byte
stream and reconstructing the java primitive data types.
DataOutput This interface can be used for writing the byte stream and converting data from the java primitive data types.
Externalizable This is written in Serializable Stream. It save and store it's contents.
FileFilter It can be used for Filtering the Pathnames.
FilenameFilter This interface used for Filter the Filenames.
ObjectInput This interface used for reading of objects and it extends the DataInput interface.
ObjectInputValidation This is a Callback interface. It allows the validation of objects within a graph.
ObjectOutput This interface used for writing of objects and it extends the DataOutput interface.
ObjectStreamConstantsThis interface used for Constants writing into Serialization Objects Stream.
Serializable This interface implementing in the java.io.Serializable interface.
Classes and Descriptions:BufferedInputStream It used for creating an internal buffer
array. It supports the mark and reset methods.
BufferedOutputStream This class used for writes byte to output stream. It implements a buffered output stream.
BufferedReader This class provides read text from character input stream and buffering characters. It also reads characters, arrays and lines.
BufferedWriter This class provides write text from character output stream and buffering characters. It also writes characters, arrays and lines.
ByteArrayInputStream It contains the internal buffer and read data from the stream.
ByteArrayOutputStream This class used for data is written into byte array. This is implement in output stream class.
CharArrayReader It used for char input stream and implements a character buffer.
CharArrayWriter This class also implements a character buffer and it uses an writer.
DataInputStream This class reads the primitive data types from the input stream in a machine format.
DataOutputStream This class writes the primitive data types from the output stream in machine format.
File This class shows a file and directory pathnames.
FileDescriptor This class uses for create a FileInputStream and FileOutputStream.
FileInputStream It contains the input byte from a file and implements an input stream.
FileOutputStream It uses for writing data to a file and also implements an output stream.
FilePermission It provides the permission to access a file or directory.
FileReader This class used for reading characters file.
FileWriter This class used for writing characters files.
FilterInputStream This class overrides all methods of InputStream and contains some other input stream.
FilterOutputStream This class overrides all methods of OutputStream and contains some other output stream.
FilterReader It reads the data from the filtered character stream.
FilterWriter It writes data from the filtered character stream.
InputStream This class represents an input stream of bytes.
InputStreamReader It reads bytes and decodes them into characters.
LineNumberReader This class has a line numbers
ObjectInputStream This class used for recover the object to serialize previously.
ObjectInputStream.GetField This class access to president fields read form input stream.
ObjectOutputStream This class used for write the primitive data types and also write the object to read by the ObjectInputStream.
ObjectOutputStream.GetFieldThis class access to president fields write in to ObjectOutput.
ObjectStreamClass Serialization's descriptor for classes.
ObjectStreamField This class describes the serializable field.
OutputStream This class represents an output stream of bytes.
OutputStreamWriter It writes bytes and decodes them into characters.
PipedInputStream In this class the data bytes are written into piped output stream. This class also connected into a piped output stream.
PipedOutputStream This class also communicates the piped input stream into piped output stream. It creates communication between both.
PipedReader It is a piped character-input stream.
PipedWriter It is a piped character-output stream.
PrintStream This class adds the functionality of another output stream.
PrintWriter This class adds the functionality of another input stream.
PushbackInputStream It also include the another function of input stream. Such as: "push back" or "unread" one byte.
PushbackReader This is a character stream reader and reads the data push back into the
stream.
RandomAccessFile It supports both reading and writing to a random access file.
Reader It used for reading character stream.
SequenceInputStream It represents the logical concatenation of other input stream.
SerializablePermission This is a serializable permission class.
StreamTokenizer It takes an input stream and parse it into "tokens" . The token to be allowed at the read time.
StringReader This is a character string class. It has character read source.
StringWriter This is also a character string class. It uses to shows the output in the buffer.
Writer It uses for writing to character stream.
Exceptions for java.io package:CharConversionException It provides detail message in the
catch block to associated with the CharConversionException
EOFException This exception indicates the end of file. When the file input stream to be end then EOFException to be occuted.
FileNotFoundException When the open file's pathname does not find then this exception to be occured.
InterruptedIOException When the I/O operations to interrupted from any causes then it becomes.
InvalidClassException Any problems to be created with class, when the Serializing runtime to be detected.
InvalidObjectException When the de-serialized objects failed then it occurs.
IOException When the I/O operations to be failed then it occurs.
NotActiveException The Serialization or deserialization operations are not active then it occurs.
NotSerializableException This exception when the instance is required to a Serializable interface.
ObjectStreamException This is a supper class of all exception class. It used for specific to Object Stream Classes.
OptionalDataException When the reading data operations to failed then it these exception occurs. It is belonging to the serialized object
StreamCorruptedException It thrown when the control information that was read form an object stream vioaltes internal consistency checks.
SyncFaieldException The sync operation is failed then SyncFaieldException to be occure.
UnsupportedEncodingExceptionThe Character Encoding is not supported.
UTFDataFormatException A molformed UTF-8 has been read in a data input stream, it implemented by data input interface.
WriteAbortedException In this exception to be thrown by the ObjectStreamException during a write operating.
Read Text from Standard IO: Java provides the standard I/O facilities for reading text through either the file or keyboard in command line. This program illustrates you how to use standard input to read the user input..
In this section, you will see how the standard I/O is used to input any thing by the keyboard or a file. This is done using the readLine() method which is the method of the BufferedReader class.
BufferedReader : The BufferedReader class is the subclass of the FilterReader class. BufferedReader class maintains the buffer and buffer state. BufferedReader class supports the read() and readLine() method for input text from a character-input stream. The buffer size may be specified but the default buffer size is enough for most purposes because the default buffer size of 8192 chars can be overridden by the creator of the stream.
In this program, as you can see that the instance variable in of the BufferedReader class which reads a single line of text from the input stream.
Here is the code of the program :
import java.io.*;
public class ReadStandardIO{ public static void main(String[] args) throws IOException{ BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Enter text : "); String str = in.readLine(); System.out.println("You entered String : "); System.out.println(str); }}
Filter Files in Java: The Filter File Java example code provides the following functionalities:
Filtering the files depending on the file extension provided by the user
User provides the file extension and then program lists all the matching files found
Program accepts directory name and file extension from user and displays the files present in the directory.
Program begins with import statement java.io.*; package, which is required for any input/output operations.
Classes Defined in the program:
OnlyExtThe constructor of the class takes file extension as parameter and then prefix it with "*." and assign into the global variable ext. The OnlyExt class implements FilenameFilter interface, so we have to implement the abstract method accept() defined in the FilenameFilter interface. The accept() method tests if a specified file should be included in a file list.
FilterFiles: The FilterFiles contains the public static void main(String args[]), which is the entry point of our program. The program first accepts directory name and file extension from the user and creates the object of OnlyExt class passing file extension as constructor parameter.
Here is the code of the program :
import java.io.*;
class OnlyExt implements FilenameFilter{ String ext;
public OnlyExt(String ext){ this.ext="." + ext; }
public boolean accept(File dir,String name){ return name.endsWith(ext); }}
public class FilterFiles{ public static void main(String args[]) throws IOException{ BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.println("Please enter the directory name : "); String dir = in.readLine(); System.out.println("Please enter file type : "); String extn = in.readLine(); File f = new File(dir); FilenameFilter ff = new OnlyExt(extn); String s[] = f.list(ff);
for (int i = 0; i < s.length; i++) { System.out.println(s[i]); } }}
Java read file line by line: In the section you will learn how to write java program to read file line by line. We will use the DataInputStream class to Read text File Line by Line.
Class DataInputStreamA data input stream is use to read primitive Java data types from an underlying input stream in a machine-independent way. An application uses a data output stream to write data that can later be read by a data input stream.
Data input streams and data output streams represent Unicode strings in a format that is a slight modification of UTF-8. (For more information, see X/Open Company Ltd., "File System Safe UCS Transformation Format (FSS_UTF)", X/Open Preliminary Specification, Document Number: P316. This information also appears in ISO/IEC 10646, Annex P.) Note that in the following tables, the most significant bit appears in the far left-hand column.
BufferedReader
Read text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.
The buffer size may be specified, or the default size may be used. The default is large enough for most purposes.
In general, each read request made of a Reader causes a corresponding read request to be made of the underlying character or byte stream. It is therefore
advisable to wrap a BufferedReader around any Reader whose read() operations may be costly, such as FileReaders and InputStreamReaders. For example, BufferedReader in = new BufferedReader(new FileReader("foo.in"));
will buffer the input from the specified file. Without buffering, each invocation of read() or readLine() could cause bytes to be read from the file, converted into characters, and then returned, which can be very inefficient.
Programs that use DataInputStreams for textual input can be localized by replacing each DataInputStream with an appropriate BufferedReader.
Here is the code of java program to Read text File Line by Line:
import java.io.*;class FileRead { public static void main(String args[]) { try{ // Open the file that is the first // command line parameter FileInputStream fstream = new FileInputStream("textfile.txt"); // Get the object of DataInputStream DataInputStream in = new DataInputStream(fstream); BufferedReader br = new BufferedReader(new InputStreamReader(in)); String strLine; //Read File Line By Line while ((strLine = br.readLine()) != null) { // Print the content on the console System.out.println (strLine); } //Close the input stream in.close(); }catch (Exception e){//Catch exception if any System.err.println("Error: " + e.getMessage()); } }}
Create File in Java: Whenever there need to be store data, you have to create a file into some directory. In this program, we will see how to create a file. This example takes the file name and text data for adding into the file.
For creating a new file File.createNewFile() method has been used. This method returns a boolean value true if the file is created otherwise return false. If the mentioned file for the specified directory is already exist then the createNewFile() method returns the false otherwise the method creates the mentioned file and return true. The constructor of the FileWriter class takes the file name which has to be buffered by theBufferedWriter stream.
The write() method of BufferedWriter class is used to create the file into specified directory.
Following code write data into new file:
out.write(read_the_Buffered_file_name);
Following code creates the object of FileWriter and BufferedWriter:
FileWriter fstream = new FileWriter(file_name);BufferedWriter out = new BufferedWriter(fstream);
Here is the code of program :
import java.io.*;
public class CreateFile{
public static void main(String[] args) throws IOException{ BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Please enter the file name to create : "); String file_name = in.readLine(); File file = new File(file_name); boolean exist = file.createNewFile(); if (!exist) { System.out.println("File already exists."); System.exit(0); } else { FileWriter fstream = new FileWriter(file_name); BufferedWriter out = new BufferedWriter(fstream); out.write(in.readLine()); out.close(); System.out.println("File created successfully."); } }}
Copying one file to another: This example illustrates how to copy contents from one file to another file. This topic is related to the I/O (input/output) of java.io package.
In this example we are using File class of java.io package. The File class is an abstract representation of file and directory pathnames. This class is an abstract, system-independent view of hierarchical pathnames. Anabstract pathname has two components:
1. An optional system-dependent prefix string,such as a disk-drive specifier, "/" for the UNIX root directory, or "\\" for a Win32 UNC pathname, and
2. A sequence of zero or more string names.
Explanation
This program copies one file to another file. We will be declaring a function called copyfile which copies the contents from one specified file to another specified file.
copyfile(String srFile, String dtFile)
The function copyfile(String srFile, String dtFile) takes both file name as parameter. The function creates a new File instance for the file name passed as parameter
File f1 = new File(srFile);File f2 = new File(dtFile);
and creates another InputStream instance for the input object and OutputStream instance for the output object passed as parameter
InputStream in = new FileInputStream(f1);OutputStream out = new FileOutputStream(f2);
and then create a byte type buffer for buffering the contents of one file and write to another specified file from the first one specified file.
// For creating a byte type bufferbyte[] buf = new byte[1024];// For writing to another specified file from buffer bufout.write(buf, 0, len);
Code of the Program :
import java.io.*;
public class CopyFile{ private static void copyfile(String srFile, String dtFile){ try{ File f1 = new File(srFile); File f2 = new File(dtFile); InputStream in = new FileInputStream(f1); //For Append the file.// OutputStream out = new FileOutputStream(f2,true);
//For Overwrite the file. OutputStream out = new FileOutputStream(f2);
byte[] buf = new byte[1024]; int len; while ((len = in.read(buf)) > 0){ out.write(buf, 0, len); } in.close(); out.close();
System.out.println("File copied."); } catch(FileNotFoundException ex){ System.out.println(ex.getMessage() + " in the specified directory."); System.exit(0); } catch(IOException e){ System.out.println(e.getMessage()); } } public static void main(String[] args){ switch(args.length){ case 0: System.out.println("File has not mentioned."); System.exit(0); case 1: System.out.println("Destination file has not mentioned."); System.exit(0); case 2: copyfile(args[0],args[1]); System.exit(0); default : System.out.println("Multiple files are not allow."); System.exit(0); } }}
Serializing an Object in Java: In this section, you will learn how to Serialize an Object in java. Serialization refers to the method of saving the object's sate into the file store or database. The serialized objects are JVM independent and can be re-serialized by any JVM. In this case the "in memory" java objects state are converted into a byte stream. This type of the file can not be understood by the user. It is a special types of object i.e. reused by the JVM (Java Virtual Machine).
This example shows you how to serialize any objects. This program takes a file name and then serialize the object. This file is machine understandable.
Default serialization mechanism for an object writes the class of the object, the class signature, and the values of all non-transient and non-static fields.
ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f));Above code has been used to create the instance of the ObjectOutput class with the ObjectOutputStream() constructor which takes the instance of the FileOuputStream as a parameter.
The ObjectOutput interface is used by implementing the ObjectOutputStream class. TheObjectOutputStream is constructed to serialize the object.
writeObject():Method writeObject() writes an object to the given stream.
Here is the code of program:
import java.io.*;
public class SerializingObject{ public static void main(String[] args) throws IOException{ BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Please enter File name : "); String file = in.readLine(); System.out.print("Enter extention : "); String ext = in.readLine(); String filename = file + "." + ext; File f = new File(filename); try{ ObjectOutput ObjOut = new ObjectOutputStream(new FileOutputStream(f)); ObjOut.writeObject(f); ObjOut.close(); System.out.println("Serializing an Object Creation completed successfully."); } catch(IOException e){ System.out.println(e.getMessage()); } }}
Deserializing an Object in java: Here, you will learn how to De-serialize the Java object. This means, converting the serialized object into in-memory java object. This program shows how to read any data or contents from the serialized object or file. It takes a file name and then converts into java object. If any exception occurs during reading the serialized file, it is caught in the catch block.
ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f));Above code of the program creates the instance of the ObjectInputStream class to deserialize that file which had been serialized by the ObjectOutputStream class. The above code creates the instance using the instance of the FileInputStream class which holds the specified file object which has to be deserialized because the ObjectOutputStream() constructor needs the input stream.
readObject():Method readObject() reads the object and restore the state of the object. This is the method of theObjectOutputStream class and methods of ObjectOutputStream class helps to traverse the object.
Here is a code of program :
import java.io.*;
public class DeserializingObject{
public static void main(String[] args) throws IOException{ BufferedReader in = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Enter File name : "); String file = in.readLine(); System.out.print("Enter extention : "); String ext = in.readLine(); String filename = file + "." + ext; File f = new File(filename); try{ ObjectInputStream obj = new ObjectInputStream(new FileInputStream(f)); System.out.println("The text : "+ obj.readObject()); obj.close(); System.out.println("Deserializing Operation Completly Successfully."); } catch(ClassNotFoundException e){ System.out.println(e.getMessage()); } catch(FileNotFoundException fe){ System.out.println("File not found "); } }}
to go in more details about I/O plz go through "http://www.roseindia.net/java/example/java/io/".