Explain the need of Exception handling.

A program rarely executes without errors for the first time. Users run applications in unexpected ways A program should handle these abnormal situations Exception handling allows to handle the code without cluttering the original code Exception handling allows error handling code to be authored in a separate block known as catch Exception handling separates the functional code with error handling code Some exception handling process can be diverted to JVM

Explain the Exceptions categories, i.e. checked and unchecked exceptions. Unchecked exceptions:

The defects in the programs are represented Passing invalid arguments to a method without parameters They reflect errors in applications

Checked exceptions:

They represent conditions that are invalid in certain areas outside of the program, such as invalid user input, files absence, network outrages. All these exceptions are subclasses of Exception class Developer has over all control to handle them Imposes robustness in applications

Provide the general form of Exception handling constructs with explanation

The constructs are trying, catch, finally, throw and throws try block: the source of an exception catch block: the exception handling block finally block: the code in finally block gets executed whether an exception is caught and handled or not

The following code illustrates the use of try, catch and finally public void openFile() { FileReader reader = null; try { reader = new FileReader("stock"); int number=0; while(number != -1){ number = reader.read(); System.out.println((char) number ); } } catch (IOException excp) { // exception handling code goes here } finally { if(reader != null)

{ try { reader.close(); } catch (IOException e) { //code to handle if file not found goes here } } System.out.println("--- File End ---"); } }

throw : to explicitly throw an exception based on the applications demand throws : diverts the responsibility of exception handling to JVM

What is user defined Exception? Explain with an example.

A user defined exception is extended by Exception class. Unconventional actions are dealt with user defined exceptions Application demanded exceptions other than APIs are defined as user defined exceptions. Ex: When the balance of an account is below zero after withdrawl, an exception can be raised like NegativeBalanceException As every exception returns a message, a user defined exception should also return a message.

The following code snippet depicts the user defined exception: public class MyException extends Exception { String msg = ""; int marks; public MyException(String str) { super(str); // the super class constructor should receive the message } public String toString() { if(marks <= 40) msg = "You have failed"; // assigning a message if(marks > 40) msg = "You have Passed"; return msg; // the message is returned when the exception is raised } } public class Sample { public static void main(String args[]) { Sample sample = new Sample(); sample.myMethd(); } public void myMethod() { try

{ int marks=0; if( marks < 40) throw new MyException(); // exception object is returned to the catch block } catch(MyException myExcp) { System.out.println("The exception is"+myExcp); } } } When the exception raises, the message You have failed will be sent to the Exception class constructor and displays it. Explain the use of Streams. A stream is flow of information. Streams are targeted to handle input and output data. Stream brings data into a program not just by assigning in the application / program Java stream opens connection to the data source, such as buffer, console, files, and sockets Data can be written onto the stream and can be read from the stream The stream can be a console, file, buffer.

The following is the classification of streams:

Byte Streams Used to handle binary data I/O Character Streams Used to handle character data I/O Unicode characters Buffered Streams Used to optimize the input and output data. Reduces the number of calls to read and write data Scanning - Allows to read formatted data, like, reading primitive types / strings Data Streams Used to handle binary I/O of primitive data types and strings

Difference between Stream classes and Reader writer classes Stream Classes :

They are byte-oriented They never support Unicode characters Supports 8-bit streams The streams supports filtering data into primitive types using DataOutputStream and DataInputStream Object serialization supports byte oriented stream Data over network passes a stream of bytes Available since JDK 1.0

Reader and Writer Classes :

They are character-oriented The never support byte streams Suttports 16-bit Unicode characters. Supports to read a group of characters at once Available since JDK 1.1

Explain and demonstrate the use of File, RandomAccessFile classes.

File class:

It represents an abstraction of files and folders Represents system independent view of hierarchical paths and files File related operations such as deleting, renaming, changing properties like read-only etc. can be performed by using File class It has methods to create directories, list files in a directory.

RandomAccessFile :

The objects of RandomAccessFile can write and read data to and from the files It has facility to write / read primitive data onto and from the files Data from any offset can be read, in contrast with other file streams, which supports only sequential access

The following code snippet illustrates to write, append and read data from a file import java.io.FileNotFoundException; import java.io.IOException; import java.io.RandomAccessFile; public class RandomAccessFileExample { public void RAFExample() { try { RandomAccessFile raf = new RandomAcessFile("books.dat", "rw"); /* instead of books.dat the following File object can also be used File randFile new File(books.dat); RandomAccessFile raf = new RandomAcessFile(randFile, "rw"); */ String books[] = new String[5]; books[0] = "Professional JSP"; books[1] = "The Java API"; books[2] = "Security in Java"; books[3] = "Java Collections Framework"; books[4] = "JSE for JEE Professional Edition"; for (int index = 0; index < books.length; index++) { raf.writeUTF(books[index]); } raf.seek(raf.length()); // file pointer at eof // appends a new record raf.writeUTF("Servlet & JSP Programming"); raf.seek(0); // file pointer at the beginning // reads data from the file while (raf.getFilePointer() < raf.length()) { System.out.println(raf.readUTF()); } } catch (FileNotFoundException e) { e.printStackTrace();

} catch (IOException e) { e.printStackTrace(); } } } Explain the use of Reader and Writer classes.

Reader and Writer classes are abstract classes of character streams Both classes have methods to read and write characters into a file The method read() reads a single character and returns an integer. Returns -1 if EOF reached The method write() writes two byte character onto a file. An array of characters can also be written to a file Reader and Writer streams can be implemented for both console and file streams. Buffered streams along with Reader and Writer classes perform well in reading files.

Provide an example and explanation of anonymous classes in Java Here we present an example and a short tutorial on anonymous classes in Java. Anonymous classes in Java are more accurately known as anonymous inner classes theres no such thing as anonymous classes without the inner. That distinction is important, because t he fact that they are anonymous inner classes means that they are defined inside another class. If youve read our article on inner versus nested classes, then you should be familiar with how inner classes work by now. An anonymous inner class is an inner class that is declared without using a class name at all and that of course is why its called an anonymous class. An anonymous inner class also has some pretty unusual syntax. Lets go through an actual example with some code of an anonymous inner class to help you understand what it is exactly: Anonymous inner class example:

class ProgrammerInterview { public void read() { System.out.println("Programmer Interview!"); } } class Website { /* This creates an anonymous inner class: */ ProgrammerInterview pInstance = new ProgrammerInterview() { public void read() { System.out.println("anonymous ProgrammerInterview"); } }; }

Understanding our anonymous inner class example In the code above, you can see that we have two classes one called Website and another called ProgrammerInterview. The ProgrammerInterview class is pretty straightforward theres just a simple method called read() that prints the text Programmer Interview! when called. The code that you need to really look closely at is inside the Website class, and is highlighted in the color red. It might look like we are creating an instance of the ProgrammerInterview class called pInstance in that code, but whats actually happening in that code is that an instance of an anonymous class is being created. An anonymous inner class is a subclass Pay special attention to the fact that inside the curly braces after the new ProgrammerInterview() code there is actually a method definition for a method named read(). This certainly does not look like we are creating a normal instance of a class because you dont normally see methods being defined at the s ame time that an instance of a class is created. Whats actually happening in the code above is that we are creating an instance of a subclass (also known as a child class) of the ProgrammerInterview class. And, the most important thing to understand here is that this instance (pInstance) is actually an instance of an anonymous subclass of the ProgrammerInterview class . Why is it called an anonymous inner class? The reason its called an anonymous inner class is because the class that we have created clearly has no name! We jump straight to creating an instance of the class, but we do not even give the class a name all we have is a reference variable (pInstance, in our example above) for the anonymous inner class. Just to emphasize the syntax differences between creating an anonymous inner class instance and a normal class instance, here is the code for creating a normal class instance assuming we want to create an instance of the ProgrammerInterview class :

/*Pay attention to the semicolon at the end, and the use of parentheses instead of braces: */ ProgrammerInterview p = new ProgrammerInterview();

The syntax above to create an instance of the ProgrammerInterview class is nothing out of the ordinary, and something youre probably already familiar with. Now, lets look at the code we have for an anonymous inner class:

Anonymous inner class syntax in Java

/*Pay attention to the opening curly braces and the fact that there's a semicolon at the very end, once the anonymous class is created: */ ProgrammerInterview pInstance = new ProgrammerInterview() { //code here... };

Anonymous inner classes and polymorphism When using anonymous inner classes, polymorphism is actually at work as well. Taking another look at our example above, note that pInstance is actually a superclass reference type that refers to a subclass object. In plain English, that means pInstance is of type ProgrammerInterview (which is the superclass), but pInstance refers to a subclass (or child class) of the ProgrammerInterview class and this is polymorphism at work. That subclass is the anonymous inner class with no name that is created inside the Website class. So, what exactly are the implications of an anonymous inner class using polymorphism? Well, it means that using the anonymous inner class reference variable type (pInstance in our example) you can only call methods that are defined inside the type (the class) of the reference variable. Using our example, this means that with pInstance we can only call methods that are defined inside the ProgrammerInterview class. You might be confused, so lets take a look at another example to understand exactly what we mean. Suppose we have the following simple classes:

class Animal{ void run() { } } class Dog extends Animal { void bark() { } }

Now, lets create an instance of the Animal class, but make it so that it points to the class that derives from it, Dog:

class Testing{

public static void main(String[] args) { Animal d = new Dog(); /*This is totally legal, calling the method run is no problem because it is defined inside the Animal class: */ d.run(); /*Compliler Error! Calling the method bark results in an error because it is not defined in the Animal class: */ d.bark(); } }

In the code above, the call to d.run() is perfectly legal, but the call to d.bark() results in a compiler error because the bark() method is not defined inside the Animal class, and our object d is of type Animal. To re emphasize this point, this makes sense because our reference variable type is of type Animal, and even though it refers to a subclass object (from class Dog in this case), it still doesnt know anything about methods defined in the Dog class. Now, what does all this have to do with anonymous inner classes? Well, if we try to invoke a method that is defined inside our anonymous class which is not overridden from the superclass, using our anonymous inner class reference, then we will get an error. That sentence must be really confusing, right? But, if you understood the fairly simple example we gave above with the Animal and Dog class, then you shouldnt have a problem understanding this concept. And, as always we will give you an example of this scenario. So, take a look: Example of anonymous class reference accessing non-overridden method

class ProgrammerInterview { public void read() { System.out.println("Programmer Interview!"); } } class Website {

ProgrammerInterview pInstance = new ProgrammerInterview() { public void read() { System.out.println("anonymous ProgrammerInterview"); } public void learn() { System.out.println("anonymous, learn ProgrammerInterview"); } }; public void readIt() { /* This is legal: */ pInstance.read(); /* Compiler error, the learn method is not also defined inside the ProgrammerInterview class: */ pInstance.learn(); } }

In the code above, we have defined a readIt method that is a part of the Website class. Inside the readIt method, we use the pInstance object that is an instance of the anonymous class that we created earlier. And, we use that pInstance object to call the learn() method, as you can see which we highlighted in red. But, because the learn() method was defined inside the anonymous inner class and not in the ProgrammerInterview class, the pInstance object (which is our anonymous inner class object and is of type ProgrammerInterview) has no idea what the learn() method is. The line pInstance.learn() will result in a compiler error something like cannot resolve symbol. Hopefully tha t all made sense to you if not, just read it again slowly! What is the purpose of an anonymous inner class? You have seen now that by creating an anonymous inner class, we can override one or more methods of a superclass. In our example above, the superclass is the ProgrammerInterview class, and the method being overridden is the read() method.

But, we could have easily done the same thing by just creating a separate class, having it extend the ProgrammerInterview class, and then just override the read() method. So, what is the need to create an anonymous inner class when we could have done the same thing using a normal, separate class? Well, the main thing is that it is quicker to just create an anonymous inner class rather than create a new separate class. Anonymous inner classes are especially useful when you only need to override a small amount of functionality (like just one method) in a superclass, and dont want to deal with the overhead of creating an entire class for something so simple. The anonymous inner class and interfaces There is actually another way a second way to create an anonymous inner class that you should be aware of. Its basically an anonymous inner class that implements an interface. Read here to find out more about the second way: Anonymous inner class interface.