Page Title

Java uses Just In Time compiler to enable high performance. JIT is used to convert the instructions into bytecodes.

When a new object is created in a program a constructor gets invoked corresponding to the class.
The constructor is a method which has the same name as class name.
If a user doesn’t create a constructor implicitly a default constructor will be created.
The constructor can be overloaded.
If the user created a constructor with a parameter then he should create another constructor explicitly without a parameter.

Oops concepts include:

Inheritance
Encapsulation
Polymorphism
Abstraction
Interface

What is Inheritance?

Inheritance means one class can extend to another class. So that the codes can be reused from one class to another class.

Existing class is known as Super class whereas the derived class is known as a sub class.

Inheritance is applicable for public and protected members only. Private members can’t be inherited.

What is Encapsulation?

Purpose of Encapsulation:

Protects the code from others.
Code maintainability.

For encapsulation, we need to make all the instance variables as private and create setter and getter for those variables. Which in turn will force others to call the setters rather than access the data directly.

What is Polymorphism?

Polymorphism means many forms.

A single object can refer the super class or sub-class depending on the reference type which is called polymorphism.

Polymorphism is applicable for overriding and not for overloading.

Method overriding happens if the sub class method satisfies the below conditions with the Super class method:

Method name should be same
Argument should be same
Return type also should be same

The key benefit of overriding is that the Sub class can provide some specific information about that sub class type than the super class.

Method overloading happens for different classes or within the same class.

For method overloading, subclass method should satisfy the below conditions with the Super class method (or) methods in the same class itself:

Same method name
Different argument type
May have different return types

Note: Polymorphism is not applicable for method overloading.

Multiple inheritance cannot be achieved in java. To overcome this problem Interface concept is introduced.

An interface is a template which has only method declarations and not the method implementation.

All the methods in the interface are internally public abstract void.
All the variables in the interface are internally public static final that is constants.
Classes can implement the interface and not extends.
The class which implements the interface should provide an implementation for all the methods declared in the interface.

We can create the Abstract class by using “Abstract” keyword before the class name. An abstract class can have both “Abstract” methods and “Non-abstract” methods that are a concrete class.

Abstract method:

The method which has only the declaration and not the implementation is called the abstract method and it has the keyword called “abstract”. Declarations are the ends with a semicolon.

An abstract class may have a Non- abstract method also.
The concrete Subclass which extends the Abstract class should provide the implementation for abstract methods.

Array	Array List
Size should be given at the time of array declaration.	Size may not be required. It changes the size dynamically.
To put an object into array we need to specify the index.	No index required.
Array is not type parameterized	ArrayList in java 5.0 are parameterized.

String - String variables are stored in “constant string pool”. Once the string reference changes the old value that exists in the “constant string pool”, it cannot be erased.

String Buffer:

Here string values are stored in a stack. If the values are changed then the new value replaces the older value.
The string buffer is synchronized which is thread-safe.
Performance is slower than the String Builder.

String Builder:

This is same as String Buffer except for the String Builder which is not threaded safety that is not synchronized. So obviously performance is fast.

public

Public members are visible in the same package as well as the outside package that is for other packages.

private

Private members are visible in the same class only and not for the other classes in the same package as well as classes in the outside packages.

default

Methods and variables declared in a class without any access specifiers are called default.

Protected

Protected is same as Default but if a class extends then it is visible even if it is outside the package.

HashMap	HashTable
Methods are not synchronized	Key methods are synchronized
Not thread safety	Thread safety
Iterator is used to iterate the values	Enumerator is used to iterate the values
Allows one null key and multiple null values	Doesn’t allow anything that is null
Performance is high than HashTable	Performance is slow

HashSet	TreeSet
Inserted elements are in random order	Maintains the elements in the sorted order
Can able to store null objects	Couldn’t store null objects
Performance is fast	Performance is slow

Abstract Class:

Abstract classes have a default constructor and it is called whenever the concrete subclass is instantiated.
Contains Abstract methods as well as Non-Abstract methods.
The class which extends the Abstract class shouldn’t require implementing all the methods, only Abstract methods need to be implemented in the concrete sub-class.
Abstract Class contains instance variables.

Interface:

Doesn’t have any constructor and couldn’t be instantiated.
Abstract method alone should be declared.
Classes which implement the interface should provide the implementation for all the methods.
The interface contains only constants.

Collection is a framework that is designed to store the objects and manipulate the design to store the objects.

Collections are used to perform the following operations:

Searching
Sorting
Manipulation
Insertion
Deletion

A group of objects is known as collections. All the classes and interfaces for collecting are available in Java util package.

Interfaces:

Collection
List
Set
Map
Sorted Set
Sorted Map
Queue

Classes:

Lists:
Array List
Vector
Linked List

Sets:

Hash set
Linked Hash Set
Tree Set

Maps:

Hash Map
Hash Table
Tree Map
Linked Hashed Map

Queue:

Priority Queue

Ordered:

It means the values that are stored in a collection is based on the values that are added to the collection. So we can iterate the values from the collection in a specific order.

Sorted:

Sorting mechanism can be applied internally or externally so that the group of objects sorted in a particular collection is based on properties of the objects.

Values added to the list is based on the index position and it is ordered by index position. Duplicates are allowed.

Array List:

Fast iteration and fast Random Access.
It is an ordered collection (by index) and not sorted.
It implements Random Access Interface.

Vector:

It is same as Array List.

Vector methods are synchronized.
Thread safety.
It also implements the Random Access.
Thread safety usually causes a performance hit.

Linked List:

Elements are doubly linked to one another.
Performance is slow than Array list.
Good choice for insertion and deletion.
In Java 5.0 it supports common queue methods peek( ), Pool ( ), Offer ( ) etc.

Maintains the insertion order and accepts the duplicates.

Java Interview Questions and Answers