Question : When you declare a method as abstract method ?
Answer : When i want child class to implement the behavior of the method.
Question : Can I call a abstract method from a non abstract method ?
Answer : Yes, We can call a abstract method from a Non abstract method in a Java abstract class
Question : What is the difference between an Abstract class and Interface in Java ? or can you explain when you use Abstract classes ?
Answer : Abstract classes let you define some behaviors; they force your subclasses to provide others. These abstract classes will provide the basic funcationality of your applicatoin, child class which inherited this class will provide the funtionality of the abstract methods in abstract class. When base class calls this method, Java calls the method defined by the child class.

  • An Interface can only declare constants and instance methods, but cannot implement default behavior.
  • Interfaces provide a form of multiple inheritance. A class can extend only one other class.
  • Interfaces are limited to public methods and constants with no implementation. Abstract classes can have a partial implementation, protected parts, static methods, etc.
  • A Class may implement several interfaces. But in case of abstract class, a class may extend only one abstract class.
  • Interfaces are slow as it requires extra indirection to find corresponding method in the actual class. Abstract classes are fast.
Neither Abstract classes or Interface can be instantiated.
Question : What is user-defined exception in java ?
Answer : User-defined expections are the exceptions defined by the application developer which are errors related to specific application. Application Developer can define the user defined exception by inherite the Exception class as shown below. Using this class we can throw new exceptions.

     Java Example :

     public class noFundException extends Exception {

     Throw an exception using a throw statement: 

      public class Fund {

      public Object getFunds() throws noFundException {

      if (Empty()) throw new noFundException();


     User-defined exceptions should usually be checked.
Question : What is the difference between checked and Unchecked Exceptions in Java ?
Answer : All predefined exceptions in Java are either a checked exception or an unchecked exception. Checked exceptions must be caught using try .. catch() block or we should throw the exception using throws clause. If you dont, compilation of program will fail.

 Java Exception Hierarchy

                    | Object |
                   | Throwable |
                    /         \
                   /           \
          +-------+          +-----------+
          | Error    |          | Exception  |
          +-------+          +-----------+
           /  |  \                   / |       \
         \________/	      \______/      \
          unchecked       checked       | RuntimeException |
		                             /   |    |      \

Question : Explain garbage collection ?
Answer : Garbage collection is an important part of Java's security strategy. Garbage collection is also called automatic memory management as JVM automatically removes the unused variables/objects from the memory. The name "garbage collection" implies that objects that are no longer needed by the program are "garbage" and can be thrown away. A more accurate and up-to-date metaphor might be "memory recycling." When an object is no longer referenced by the program, the heap space it occupies must be recycled so that the space is available for subsequent new objects. The garbage collector must somehow determine which objects are no longer referenced by the program and make available the heap space occupied by such unreferenced objects. In the process of freeing unreferenced objects, the garbage collector must run any finalizers of objects being freed.

In Java, it is good idea to explicitly assign null into a variable when no more in use.
Question : How you can force the garbage collection ?
Answer : Garbage collection automatic process and can't be forced. We can call garbage collector in Java by calling System.gc() and Runtime.gc(), JVM tries to recycle the unused objects, but there is no guarantee when all the objects will garbage collected.
Question : What are the field/method access levels (specifiers) and class access levels ?
Answer : Each field and method has an access level:
  • private: accessible only in this class
  • (package): accessible only in this package
  • protected: accessible only in this package and in all subclasses of this class
  • public: accessible everywhere this class is available
Similarly, each class has one of two possible access levels:
  • (package): class objects can only be declared and manipulated by code in this package
  • public: class objects can be declared and manipulated by code in any package
For both fields and classes, package access is the default, and is used when no access is specified
Question : What are the static fields & static Methods ?
Answer : If a field or method defined as a static, there is only one copy for entire class, rather than one copy for each instance of class. static method cannot accecss non-static field or call non-static method

Example Java Code

static int counter = 0;

A public static field or method can be accessed from outside the class using either the usual notation:


or using the class name instead of the name of the class object:

Java- class-name.field-or-method-name
Question : What are the Final fields & Final Methods ?
Answer : Fields and methods can also be declared final. A final method cannot be overridden in a subclass. A final field is like a constant: once it has been given a value, it cannot be assigned to again.

Java Code

private static final int MAXATTEMPTS = 10;
Question : Describe the wrapper classes in Java ?
Answer : Wrapper class is wrapper around a primitive data type. An instance of a wrapper class contains, or wraps, a primitive value of the corresponding type.

Following table lists the primitive types and the corresponding wrapper classes:

Primitive Wrapper
boolean java.lang.Boolean
byte java.lang.Byte
char java.lang.Character
double java.lang.Double
float java.lang.Float
int java.lang.Integer
long java.lang.Long
short java.lang.Short
void java.lang.Void
Question : What are different types of inner classes ?
Answer : Inner classes nest within other classes. A normal class is a direct member of a package. Inner classes, which became available with Java 1.1, are four types

  • Static member classes
  • Member classes
  • Local classes
  • Anonymous classes
Static member classes - a static member class is a static member of a class. Like any other static method, a static member class has access to all static methods of the parent, or top-level, class.

Member Classes - a member class is also defined as a member of a class. Unlike the static variety, the member class is instance specific and has access to any and all methods and members, even the parent's this reference.

Local Classes - Local Classes declared within a block of code and these classes are visible only within the block.

Anonymous Classes - These type of classes does not have any name and its like a local class

 Java Anonymous Class Example

 public class SomeGUI extends JFrame
   ... button member declarations ...

   protected void buildGUI()
      button1 = new JButton();
      button2 = new JButton();

         new java.awt.event.ActionListener()                               <------ Anonymous Class
            public void actionPerformed(java.awt.event.ActionEvent e)
               // do something
Question : What are the uses of Serialization?
Answer : In some types of applications you have to write the code to serialize objects, but in many cases serialization is performed behind the scenes by various server-side containers.

These are some of the typical uses of serialization:

  • To persist data for future use.
  • To send data to a remote computer using such client/server Java technologies as RMI or socket programming.
  • To "flatten" an object into array of bytes in memory.
  • To exchange data between applets and servlets.
  • To store user session in Web applications.
  • To activate/passivate enterprise java beans.
  • To send objects between the servers in a cluster.
Question : what is a collection ?
Answer : Collection is a group of objects. java.util package provides important types of collections. There are two fundamental types of collections they are Collection and Map. Collection types hold a group of objects, Eg. Lists and Sets where as Map types hold group of objects as key, value pairs Eg. HashMap and Hashtable.
Question : For concatenation of strings, which method is good, StringBuffer or String ?
Answer : StringBuffer is faster than String for concatenation.
Question : What is Runnable interface ? Are there any other ways to make a java program as multithred java program?
Answer : There are two ways to create new kinds of threads:

- Define a new class that extends the Thread class
- Define a new class that implements the Runnable interface, and pass an object of that class to a Thread's constructor.
- An advantage of the second approach is that the new class can be a subclass of any class, not just of the Thread class.

    Here is a very simple example just to illustrate how to use the second approach to creating threads: 

   class myThread implements Runnable {
      public void run() {
	System.out.println("I'm running!");

public class tstRunnable {
    public static void main(String[] args) {
	myThread my1 = new myThread();
	myThread my2 = new myThread();
	new Thread(my1).start();
	new Thread(my2).start();

The Runnable interface has only one method:
public void run();
Thus, every class (thread) implements the Runnable interface, has to provide logic for run() method
Question : How can i tell what state a thread is in ?
Answer : Prior to Java 5, isAlive() was commonly used to test a threads state. If isAlive() returned false the thread was either new or terminated but there was simply no way to differentiate between the two.

Starting with the release of Tiger (Java 5) you can now get what state a thread is in by using the getState() method which returns an Enum of Thread.States. A thread can only be in one of the following states at a given point in time.

NEW A Fresh thread that has not yet started to execute.
RUNNABLE A thread that is executing in the Java virtual machine.
BLOCKED A thread that is blocked waiting for a monitor lock.
WAITING A thread that is wating to be notified by another thread.
TIMED_WAITING A thread that is wating to be notified by another thread for a specific amount of time
TERMINATED A thread whos run method has ended.
The folowing code prints out all thread states. 

public class ThreadStates{
 public static void main(String[] args){
  Thread t = new Thread();
  Thread.State e = t.getState(); 
  Thread.State[] ts = e.values(); 
  for(int i = 0; i < ts.length; i++){
Question : What methods java providing for Thread communications ?
Answer : Java provides three methods that threads can use to communicate with each other: wait, notify, and notifyAll. These methods are defined for all Objects (not just Threads). The idea is that a method called by a thread may need to wait for some condition to be satisfied by another thread; in that case, it can call the wait method, which causes its thread to wait until another thread calls notify or notifyAll.
Question : What is the difference between notify and notify All methods ?
Answer : A call to notify causes at most one thread waiting on the same object to be notified (i.e., the object that calls notify must be the same as the object that called wait). A call to notifyAll causes all threads waiting on the same object to be notified. If more than one thread is waiting on that object, there is no way to control which of them is notified by a call to notify (so it is often better to use notifyAll than notify).
Question : What is synchronized keyword? In what situations you will Use it?
Answer : Synchronization is the act of serializing access to critical sections of code. We will use this keyword when we expect multiple threads to access/modify the same data. To understand synchronization we need to look into thread execution manner.

Threads may execute in a manner where their paths of execution are completely independent of each other. Neither thread depends upon the other for assistance. For example, one thread might execute a print job, while a second thread repaints a window. And then there are threads that require synchronization, the act of serializing access to critical sections of code, at various moments during their executions. For example, say that two threads need to send data packets over a single network connection. Each thread must be able to send its entire data packet before the other thread starts sending its data packet; otherwise, the data is scrambled. This scenario requires each thread to synchronize its access to the code that does the actual data-packet sending.

If you feel a method is very critical for business that needs to be executed by only one thread at a time (to prevent data loss or corruption), then we need to use synchronized keyword.


Some real-world tasks are better modeled by a program that uses threads than by a normal, sequential program. For example, consider a bank whose accounts can be accessed and updated by any of a number of automatic teller machines (ATMs). Each ATM could be a separate thread, responding to deposit and withdrawal requests from different users simultaneously. Of course, it would be important to make sure that two users did not access the same account simultaneously. This is done in Java using synchronization, which can be applied to individual methods, or to sequences of statements.

One or more methods of a class can be declared to be synchronized. When a thread calls an object's synchronized method, the whole object is locked. This means that if another thread tries to call any synchronized method of the same object, the call will block until the lock is released (which happens when the original call finishes). In general, if the value of a field of an object can be changed, then all methods that read or write that field should be synchronized to prevent two threads from trying to write the field at the same time, and to prevent one thread from reading the field while another thread is in the process of writing it.

Here is an example of a BankAccount class that uses synchronized methods to ensure that deposits and withdrawals cannot be performed simultaneously, and to ensure that the account balance cannot be read while either a deposit or a withdrawal is in progress. (To keep the example simple, no check is done to ensure that a withdrawal does not lead to a negative balance.)

public class BankAccount {
    private double balance;

    // constructor: set balance to given amount
    public BankAccount( double initialDeposit ) {
        balance = initialDeposit;

    public synchronized double Balance( ) {
        return balance;

    public synchronized void Deposit( double deposit ) {
        balance += deposit;

    public synchronized void Withdraw( double withdrawal ) {
        balance -= withdrawal;

Note: that the BankAccount's constructor is not declared to be synchronized. That is because it can only be executed when the object is being created, and no other method can be called until that creation is finished.

There are cases where we need to synchronize a group of statements, we can do that using synchrozed statement.

Java Code Example

synchronized ( B ) {
    if ( D > B.Balance() ) {
    else {
        B.Withdraw( D );

Question : What is serialization ?
Answer : Serialization is the process of writing complete state of java object into output stream, that stream can be file or byte array or stream associated with TCP/IP socket.
Question : What does the Serializable interface do ?
Answer : Serializable is a tagging interface; it prescribes no methods. It serves to assign the Serializable data type to the tagged class and to identify the class as one which the developer has designed for persistence. ObjectOutputStream serializes only those objects which implement this interface.
Question : How do I serialize an object to a file ?
Answer : To serialize an object into a stream perform the following actions:

- Open one of the output streams, for exaample FileOutputStream
- Chain it with the ObjectOutputStream - Call the method writeObject() providingg the instance of a Serializable object as an argument.
- Close the streams

    Java Code

                fOut= new FileOutputStream("c:\\emp.ser");
	   out = new ObjectOutputStream(fOut);
	   out.writeObject(employee);  //serializing 
	   System.out.println("An employee is serialized into c:\\emp.ser");

      }  catch(IOException e){

Question : How do I deserilaize an Object?
Answer : To deserialize an object, perform the following steps:

- Open an input stream
- Chain it with the ObjectInputStream - Call the method readObject() and cast tthe returned object to the class that is being deserialized.
- Close the streams
Java Code

    fIn= new FileInputStream("c:\\emp.ser");
     in = new ObjectInputStream(fIn);
    //de-serializing employee
    Employee emp = (Employee) in.readObject();
    System.out.println("Deserialized " + emp.fName + " " 
                 + emp.lName + " from emp.ser ");
   }catch(IOException e){
   }catch(ClassNotFoundException e){
        e.printStackTrace();  }

Question : What is Externalizable Interface ?
Answer : Externalizable interface is a subclass of Serializable. Java provides Externalizable interface that gives you more control over what is being serialized and it can produce smaller object footprint. ( You can serialize whatever field values you want to serialize)

This interface defines 2 methods: readExternal() and writeExternal() and you have to implement these methods in the class that will be serialized. In these methods you'll have to write code that reads/writes only the values of the attributes you are interested in. Programs that perform serialization and deserialization have to write and read these attributes in the same sequence.


Java Interview Questions 1 Java Interview Questions 2 Java Interview Questions 3 Java Interview Questions 4 Java Interview Questions 5