Java Interview Questions

Java Interview Question

2010-11-09T07:18:00.000-08:00

Next >>

Java Interview Question 1:

What is a class?

Class is a template for a set of objects that share common properties and a common behavior.

Java Interview Question 2:
What is Constructor?

When you create a new instance (a new object) of a class using the new keyword, a constructor for that class is called. Constructors are used to initialize the instance variables (fields) of an object. Constructors must have the same name as the class and can not return a value. The first line of a constructor must either be a call on another constructor in the same class (using this), or a call on the superclass constructor (using super). If the first line is neither of these, the compiler automatically inserts a call to the parameterless super class constructor.

Java Interview Question 3:
What is Default Constructor?

Java provides a default constructor, if a class defined by the code does not have any constructor. If you define any constructor for your class, no default parameterless constructor is automatically created by the compiler. The default constructor calls the default parent constructor (super()) and initializes all instance variables to default value (zero for numeric types, null for object references, and false for booleans). The access modifier (public/private/etc.) of the default constructor is the same as the class itself.

Java Interview Question 4:
How are this() and super() used with constructors?

this() is used to invoke a constructor of the same class with a different parameter list. super() is used to invoke a superclass constructor. If a constructor uses super, it must be the first statement in the body of a constructor.

Next >>

Java Interview Question 6

2010-06-17T15:26:00.000-07:00

<< Previous Next >>

Java Interview Question 16:
What is encapsulation?

Imagine a class, RectExample with public instance variables as the following code demonstrates:

public class RectExample {

public int length;
public int breadth;

...

}

Since the instance variables of RectExample are public, another programmer can easily modify the instance variables in a way that helps their code logic but totally alters the way your class works:

public class AnotherRectExample {

   public static void main (String [] args) {

      RectExample b = new RectExample ();

      b.length = -5; // Legal but not good!!

}

}

In the above code another programmer is trying to set a value to the length variable that you dont want. So we need to make changes to the class in such a way that no one can alter the values directly. The ability to make changes in your code without breaking the code of all others who use your code is a key benefit of encapsulation. This can be achieved by making the instance variables as private and then have a set of public methods that others can use to access the variables. The access methods are referred as getters and setters or accessors and mutators. Declaring variables as private in a class, gives access to the variables to only member functions of the class. A next level of accessibility is provided by the protected keyword which gives the derived classes the access to the instance variables of the base class.

Example:

public class SquareExample {

// protect the instance variable only an instance of your class can access it

private int length;

// Provide public getters and setters

public int getLength() {

return length;

}

public void setLength(int newLength) {

length = newLength;

}

}

Encapsulation can be defined as the technique of making the fields in a class private and providing access to the fields via public methods. The main benefit of encapsulation is the ability to modify your implemented code without breaking the code of others who use your code. With this feature Encapsulation gives maintainability, flexibility and extensibility to your code.

<< Previous Next >>

Java Interview Question 5

2010-06-17T15:21:00.000-07:00

<< Previous Next >>

Java Interview Question 14:
What's the difference between == and equals method?

The “==” operator compares two object references to check whether they refer to the same instances or not. That is, they looks at the actually memory address to see if it is actually the same object. Whereas the equals method compares the contents of the objects.

For example, consider the following

String str1 = new String("abcd");

String str2 = new String("abcd");

The line of code create a new String object, with a value of "abcd", and assign it to a reference variable str1 and str2.

Now, if you use the "equals()" method to check for their equivalence as

if(str1.equals(str2))

System.out.println("str1.equals(str2) is TRUE");

else

System.out.println("str1.equals(str2) is FALSE");

The output will be TRUE as the 'equals()' method compares the contents of the objects.

Lets check the '==' operator..

if(str1==str2)

System.out.printlln("str1==str2 is TRUE");

else

System.out.println("str1==str2 is FALSE");

The output will be FALSE because both str1and str2 are pointing to two different objects even though both of them share the same string content. It is because of 'new String()' everytime a new object is created.

Java Interview Question 15:
What is inheritance?

In OOPs, the concept of inheritance provides the idea of reusability. That is, when we want to create a new class and there is already a class that includes some of the code that we want, we can derive our new class from the existing class. We can add additional features to the derived class. The derived class will have combined features of both the classes. In other words, inheritance can be defined as the capability of a class to use the properties and methods of another class while adding its own functionality. Java uses the extends keyword to set the relationship between a base class (also a superclass or a parent class) and a derived class (also a subclass, extended class, or child class). Only properties with access modifier public and protected can be accessed in child class. Constructors are not inherited by subclasses, but the constructor of the superclass can be invoked from the subclass. Each class is allowed to have one direct superclass, and each superclass has the potential for an unlimited number of subclasses:

The syntax for creating a subclass.

class A extends B{
// new fields and methods would go here

}
Here, class A is the subclass and B is the superclass

<< Previous Next >>

Java Interview Question 4

2010-06-17T15:18:00.000-07:00

<< Previous Next >>

Java Interview Question 11:

What is a thread?

A thread can be defined as a separate stream of execution that takes place simultaneously with and independently of everything else that might be happening. A thread runs independently of anything else happening in the computer. Without threads an entire program can be held up by one CPU intensive task or one infinite loop, intentional or otherwise. With threads the other tasks that don't get stuck in the loop can continue processing without waiting for the stuck task to finish.

Java Interview Question 12:
What are the two ways of creating thread and which is the most advantageous method?

There are 2 ways in which a thread can be created.

Extend the java.lang.Thread class.
Implement the Runnable interface.

Extending java.lang.Thread class

Extend the java.lang.Thread class.
Override the run() method.
Create an instance of the subclass and invoke the start() method on it, which will create a new thread of execution. e.g.

public class MyThread extends Thread{

      public void run(){

           // the code that has to be executed in a separate new thread goes here

      }

    public static void main(String [] args){

            MyThread t = new MyThread();
            t.start();

    }

}

Implementing Runnable interface

The class will have to implement the run() method in the Runnable interface. Create an instance of this class. Pass the reference of this instance to the Thread constructor, a new thread of execution will be created. e.g.

public class MyRunnable implements Runnable{

    public void run(){

        // the code that has to be executed in a separate new thread goes here

    }

    public static void main(String [] args){

         MyRunnable r = new MyRunnable();
   Thread t = new Thread(r);
         t.start();

     }

}

When creating threads, there are two reasons why implementing the Runnable interface may be preferable to extending the Thread class:

Extending the Thread class means that the subclass cannot extend any other class, whereas a class implementing the Runnable interface has this option.
A class might only be interested in being runnable, and therefore, inheriting the full overhead of the Thread class would be excessive.

Java Interview Question 13:
What all constructors are present in the Thread class?

The no-arg constructor in class Thread.

Thread()

Overloaded constructors in class Thread.

Thread(Runnable target)
Thread(Runnable target, String name)
Thread(String name)

<< Previous Next >>

Java Interview Question 3

2010-06-17T15:15:00.000-07:00

<< Previous Next >>

Java Interview Question 8:

How does Java handle exceptions using try –catch block?

When an exceptional event occurs in Java, an exception is said to be "thrown." The code that's responsible for doing something about the exception is called an "exception handler," and it "catches" the thrown exception. Exception handling works by transferring the execution of a program to an appropriate exception handler when an exception occurs. We need a way to tell the JVM what code to execute when a certain exception happens. To do this, we use the try and catch keywords. The try is used to define a block of code in which exceptions may occur. This block of code is called a guarded region (which really means "risky code goes here"). If an exception occurs within the try block, that exception is handled by an exception handler associated with it. To associate an exception handler with a try block, we must put a catch block after it. The catch block contains the code that is executed in exceptional circumstances. We can associate exception handlers with a try block by providing one or more catch blocks directly after the try block. No code can be between the end of the try block and the beginning of the first catch block.

Java Interview Question 9:

What is the use of the finally block?

Finally is the block of code that needs to be executed under any circumstance. The code in finally block will execute even if an exception is occurred. When an exception is thrown, the statements in the try block written after the statement in which the exception occurred are ignored. The finally block is used to process certain statements, no matter whether an exception is thrown or not. "Finally" creates a block of code that will be executed after try/catch block has completed and before the code following the try/catch block. If there is a catch block associated with the try block, the finally clause is executed after the catch block. If an exception is thrown, finally block will execute even if no catch statements matches the exception. Finally is guaranteed to execute, even if no exceptions are thrown. Finally block is an ideal position for closing the resources such as file handle or a database connection etc.

Java Interview Question 10:

What are transient variables in java?

Transient variables are variable that cannot be serialized.

<< Previous Next >>

Java Interview Questions 2

2010-06-17T15:13:00.000-07:00

<< Previous Next >>

Java Interview Question 5:
What is an abstract class?

Abstract class is a class which contain one or more abstract methods, which has to be implemented by sub classes. A class that is abstract may not be instantiated. Its sole purpose is to be extended (subclassed). When an abstract class is subclassed, the subclass usually provides implementations for all of the abstract methods in its parent class. However, if it does not, the subclass must also be declared abstract. A class may be declared abstract even if it has no abstract methods. This prevents it from being instantiated.

Java Interview Question 6:
What is the final keyword denotes?

A final keyword can be used for class, method and variables. The keyword final denotes that it is the final implementation for that class or method or variables.

Final class: A class that is declared final cannot be a superclass. That is, no other class can extend (inherit from) a final class. In other words, Java classes declared as final cannot be extended/subclassed. All methods in a final class are implicitly final. Many of the Java standard library classes are final, for example java.lang.System and java.lang.String

Final method: If declaring an entire class final is too heavy-handed for your needs, you can declare some or all the class’s methods final instead. A final method indicate that the method cannot be overridden by subclasses. A method is marked as final if it has an implementation that should not be changed.

Final variable: A final variable can only be assigned once. The value of a final variable cannot change after it has been initialized.. A variable that is declared as final and not initialized is called a blank final variable.

Java Interview Question 7:
What is an exception?

The term "exception" means "exceptional condition" which occurs during the execution of a program, that disrupts the normal flow of the program's instructions.

<< Previous Next >>