Most Asked Java Interview Questions

1. What are the similarities and difference between

C++ and Java?
Java, unlike C++, doesn’t have pointers, operator overloading, typedef keyword,
define keyword, structures, unions, enumeration, functions, goto statements,
templates, and default parameters. Java doesn’t have functions as it is Object
Oriented. It has methods instead.

Most of you are confused between methods and functions. Functions, used in C++,
and methods, used in Java, have the same functionality with a minor difference.
Functions are a set of codes that are called in any part of the program by referring to
its name. Methods are a set of codes that are called in any part of the program
by referring to its name and these are associated with an object.

There is no automatic coercion in Java, unlike C++. Coercion is to convert one data
type to another. In Java, coercion is explicitly made and is performed using code
instructions.

In Java, variables are not declared separately. They are the part of a class.

Java supports interface inheritance and not implementation inheritance. i.e, it

doesn’t support private, public and protected inheritance but supports multiple
inheritance.

There’s no scope resolution operator (::) in Java. Java uses the dot for everything
but can get away with it since you can define elements only within a class.

Unlike C++, Java has garbage collection and multithread support.

Even though Java doesn’t support operator overloading, it supports function

overloading. Like C++, it also supports internationalization and exception handling.
Exception handling in Java is different because there are no destructors.

2. Explain JVM, JRE, and JDK.

JVM (Java Virtual Machine): During the development of Java, the developers faced
many problems because as the OS gets updated, the system was not able to run the
previously written codes. To rectify this problem, JVM came into existence. It is an
abstract machine that is present in the user’s computer and converts the bytecode
into machine code. Thus, it enables a computer to run a java program. It is a
specification that provides a run-time environment in which Java bytecode can be
executed. It follows three notations:

Specification: It is a document that describes the implementation of the Java virtual

machine. It is provided by Sun and other companies.

Implementation: It is a program that meets the requirements of JVM specification.

Runtime Instance: An instance of JVM is created whenever you write a

java command on the command prompt and run the class.

JRE (Java Runtime Environment): JRE refers to a software package in which

java bytecode can be executed. It implements the JVM (Java Virtual Machine) and
provides all the class libraries and other support files that JVM uses at runtime.

JDK (Java Development Kit): This tool is necessary to compile, document and
package Java programs. The JDK includes JRE which contains tools for Java
programmers. Along with JRE, it includes an interpreter/loader, a documentation
generator (javadoc), an archiver (jar), a compiler (javac), and other tools needed in
Java development. To put it simply, it encloses the JRE and the development tools.

3. Explain public static void main(String args[]).

public: Public is an access modifier. Access modifiers are used to specify who can
access this method and hence, public specifies that this method will be accessible to
any class.

static: Static is a keyword in java to identify if the program is class-based or not

because, in Java, a program cannot be accessed without creating the instance of a
Class.

void: It is the return type of the method. Void defines the method that doesn’t return
any value.
main: Main is the method that is searched by the JVM as it is considered as the
starting point of the program.

String args[]: It is the parameter passed to the main method.

In this, only the name of the string can be changed and the rest remains constant.

4. Why is Java platform independent?

Java is created keeping in mind the concept of “write once run anywhere”. A code
once compiled, can run on any operating system as it uses the JVM. The source code
is converted into a bytecode by the Java compiler and then, the JVM on the user’s
system converts it into machine codes. As these machine codes can run on any
system irrespective of its underlying operating system, it is platform independent.

5. Explain Final keyword in java.

The final keyword is used in variables, classes, and methods to restrict the usage.

In variables, the value of the final variable is constant and cannot be changed.

In classes, final classes can’t be inherited.

In methods, a final method can never be overridden.

6. When is the super keyword used?

A super keyword is used to refer the following:

Immediate parent class constructor

Immediate parent class variable
Immediate parent class method.

super() is used to invoke the immediate parent class constructor.

An example for how the super keyword is used to access the data members of a
parent class is given below:

class Animal{
String color="white";
}
class Dog extends Animal{
String color="black";
void printColor(){
System.out.println(color);//prints color of Dog class
System.out.println(super.color);//prints color of Animal class
}
}
class TestSuper1{
public static void main(String args[]){
Dog d=new Dog();
d.printColor();
}}

An example for how the super keyword is used to invoke a method of a parent class
is given below:

class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void eat(){System.out.println("eating bread...");}
void bark(){System.out.println("barking...");}
void work(){
super.eat();
bark();
}
}
class TestSuper2{
public static void main(String args[]){
Dog d=new Dog();
d.work();
}}

An example for how the super keyword is used to invoke a constructor of a parent
class is given below:

class Animal
{
Animal(){System.out.println("animal is created");}
}
class Dog extends Animal{
Dog(){
super();
System.out.println("dog is created");
}
}
class TestSuper3{
public static void main(String args[]){
Dog d=new Dog();
}}

7. Compare SWING components to standard AWT.

Swing is an extension and not a replacement for the AWT (Abstract Window Toolkit).
There are few overlaps between AWT and Swing. For example, a Swing JButton
component might be viewed as an improved functional replacement for an AWT
Button component.

One of the advantages of Swing components is that because the components are
not rendered on the screen by the operating system, the look, and feel of a
component does not change as the application or applet is executed on different
platforms running under different operating systems.

Furthermore, it is possible to cause Swing components to mimic the look and feel of
a specific platform no matter what platform the program is running on. This is known
as pluggable look and feel. Swing components support the JDK 1.1 Delegation Event
Model.

From an event handling point of view, Swing components operate the same as AWT
components except that Swing provides a number of new event types. Many Swing
components don't have an AWT counterpart. A number of new and exciting
components are included in the Swing library that doesn't exist in the AWT like
tooltips, progress bars, trees, etc.

8. What is the difference between ‘throw’ and

‘throws’ in Java Exception Handling?
The throw keyword is used to throw Exception from any method or static block
whereas the throws keyword is used to indicate the method in which the Exception
can possibly be thrown.

If any method throws checked Exception, then the user can either handle this
exception by using the try-catch block or they can re-throw it by declaring another
‘throws’ clause during the declaration of methods.

The throw clause can be used in any part of the program like

throw
throw new Exception(“You have some exception”)
throw new IOException(“Connection failed!!”)
throws
throws IOException, NullPointerException, ArithmeticException

The above mentioned are some of the most asked Java interview questions.

Most Commonly Asked

For more, stay in touch with FACE Prep.

Java Interview Questions – Set 2

1. What are ArrayList and Vector?

Array:

Generally, Array is a collection of similar type of elements that are arranged in

adjacent memory addresses. In Java, Array is an object which contains similar types
of elements. By default, the size of these elements stored in an array cannot be
changed. i.e, you will give a size to the array and you cannot expand or reduce it
later. If you want to change the size of the array, you have to create a new array and
copy the data that you want. But this process is tedious. But, in Platforms such as
Java 6 and Java 7, built-in classes like ArrayList are introduced.

List Interface:

The list interface is the ordered collection of objects in which you can store duplicate
values. In list interface, you can insert elements in desired positions as it has insertion
and positional access.

ArrayList:
The class ArrayList is an array-based implementation of the List interface. All the
elements of the ArrayList are stored in a Java array and hence, it has fixed size in the
beginning. For example, an array list by the name of xyz is of the size m. In the
beginning, the array xyz is capable of storing a maximum of m elements. But, when
the (m+1)th element is added to the array, the size of the array will be increased by
50% of its original size automatically. This is done by acquiring a bigger array and
copying all the elements of the current array to the bigger array.

Synchronization:

Thread synchronization is a mechanism which ensures that two or more processes do

not simultaneously execute the same program section.

Vector:

Like ArrayList, Vector also implements List interface and uses insertion order. But,
unlike ArrayList, Vector is synchronized. Even though the adding, searching, updating
and deleting of arrays are not carried out satisfactorily because of the
synchronization, the vectors can grow and shrink as required to accommodate
elements. In the beginning, the using this vector class object will create an initial
capacity of m. If the (m+1)th element is added, the size of the vector is doubled.

Declaring the vector in its default form as in Vector xyz = new Vector(); will create
10 initial capacity. In case of Vector xyz = new Vector(int size, int incr); the initial
capacity is specified by the size and the increment of the size is specified by incr.

Differences between ArrayList and Vector:

ArrayList is not synchronized, but Vector is synchronized. Hence, the ArrayList is fast
and Vector is slow.
If the element m+1 is inserted into an m array, then the size of the ArrayList is
increased by 50% and that of the vector is doubled.
The ArrayList doesn’t define the increment size while the Vector can define the
increment size (eg: Vector xyz = new Vector(int size, int incr);)

2. What is Polymorphism?
Poly in Greek means many and morph means forms. Polymorphism, in simple words,
is the ability of one function to take up many forms. In Java, Polymorphism is the
ability of the language to process objects of various types and class through a single
interface. For example, you will behave as a customer in the shop, as a student in
college, as an employee in the workplace and as a fan in the stadium. Here, you are
polymorphic.

Polymorphism is of two types as:

Compile Time Polymorphism

Run Time Polymorphism

3. What is Compile Time Polymorphism or Static

Binding?
This type of polymorphism uses method overloading. i.e, There are multiple methods
in a class with same name and different types/ number of arguments/ parameters. At
the time of compiling, Java compiler will just look at the type or the number of
arguments given to know which method to invoke.

Eg:

class DemoOverload{
public int add(int x, int y){ //method 1
return x+y;
}
public int add(int x, int y, int z){ //method 2
return x+y+z;
}
public int add(double x, int y){ //method 3
return (int)x+y;
}
public int add(int x, double y){ //method 4
return x+(int)y;
}
}
class Test{
public static void main(String[] args){
DemoOverload demo=new DemoOverload();
out.println(demo.add(2,3)); //method 1 called
out.println(demo.add(2,3,4)); //method 2 called
out.println(demo.add(2,3.4)); //method 4 called
out.println(demo.add(2.5,3)); //method 3 called
}
}

4. What is Run Time Polymorphism or Dynamic Method

Dispatch?
This is a process where the call to the overridden method is resolved at run-time
rather than during compile-time. In this process, the overridden method is called
through the superclass’ reference variable. This type of polymorphism allocates the
memory space for the object at runtime.

Eg:

class Car{
void run(){System.out.println("running");}
}
class Audi extends Car{
void run(){System.out.println("Running safely with 70km");
}
publicstatic void main(String args[]){
Car c = new Audi(); //upcasting
run();
}
}

Output:

Running safely in 70km

In the above program, we created two classes called Car and Audi. The class Audi,
the child class, extends the parent class, Car. Then, the run method is called by the
reference variable of the parent class, i.e, c. Since it refers to the child class’ object
and also, as the child class’ method overrides the Parent class method, the subclass
method is invoked at runtime.

Eg:
class Shape{
void draw(){System.out.println("drawing...");}
}
class Rectangle extends Shape{
void draw(){System.out.println("drawing rectangle...");}
}
class Circle extends Shape{
void draw(){System.out.println("drawing circle...");}
}
class Triangle extends Shape{
void draw(){System.out.println("drawing triangle...");}
}
class TestPolymorphism2{
public static void main(String args[]){
Shape s;
s=new Rectangle();
draw();
s=new Circle();
draw();
s=new Triangle();
draw();
}
}

Output:

drawing rectangle...
drawing circle...
drawing triangle...

5. What is a Servlet?
Servlets and applets came into the picture as soon as the web was used for
delivering services. This is because the service providers recognized the need for a
more dynamic content. Hence, at first, the applets was developed. It completely
focused on using the client Platform to provide the dynamic experience. At the same
time, the servlets are developed to give the dynamic experience from the server
platform.
Java servlet is a Java program that extends the capabilities of a server. A Java Servlet
container provides lifecycle management which is a single process to share and
manage application-wide resources and interaction with a Web server. The primary
use of the Java Servlet is to define a robust mechanism for sending content to a
client as according to the definition of the Client/Server model. Also, Servlets natively
supports HTTP.

It processes the input from client side and generates the response in terms of the
HTML page, Applets or Javascript. The lifecycle of a servlet consists of init( ), service(
), and destroy( ).

6. How is Multiple Inheritance supported in Java?

Java supports multiple inheritance through its interfaces. The reason for not
supporting multiple inheritance through classes is to avoid the conflict and
complexity that arises due to it and keep Java a Simple Object-Oriented Language.

This decision is taken because, in C++, there is a special case of multiple inheritance
(in Diamond problem) where you have a multiple inheritance with two classes or
more classes overriding a method. So, Java developers decided to avoid such
conflicts and didn’t allow multiple inheritance through classes at all.

The multiple inheritance through interface is shown below:

InterfaceA.java
package com.faceprep.inheritance;
public interface InterfaceA {
public void xyz();
}

InterfaceB.java
package com.faceprep.inheritance;
public interface InterfaceB {
public void xyz();
}

Both the interfaces given above are declaring the same method. Now, an interface
extending both these interfaces is implemented.
InterfaceC.java
package com.faceprep.inheritance;
public interface InterfaceC extends InterfaceA, InterfaceB { //same method is declared
in both InterfaceA and InterfaceB
public void xyz();
}

The above program will generate a clean output because the interfaces are only
declaring the methods and the actual implementation will be done by concrete
classes implementing the interfaces. So there is no possibility of any kind of
ambiguity in multiple inheritance through interfaces.

7. Explain finalize() method.

Unlike c+ +, Java doesn’t need destructors as the ‘Garbage Collector‘ automatically
destroys the objects for us. If there is no reference is present to an object, Garbage
Collector assumes that it is no longer needed, and hence, the memory occupied by
the object can be freed. The finalize() method is called by the garbage collector on
an object when garbage collection determines that there are no more references to
the object.

Sometimes an object can hold non-java resources such as file handle or database
connection. Hence, you have to make sure that these resources are also released
before the object is destroyed. The finalize() is used as it performs many operations,
including bringing the object back to life. To do this, provide the protected void
finalize() in the object class. You can override this method in your class and do the
required tasks. Right before an object is freed, the java runtime calls the finalize()
method on that object.

8. What happens when an Object is created?

Several things happen in a particular order to ensure the object is constructed
properly:

1. Memory is allocated from the heap to hold all instance variables and
implementation-specific data of the object and its superclasses. Implementation-
specific data includes pointers to class and method data.
2. The instance variables of the objects are initialized to their default values.
3. The constructor for the most derived class is invoked. The first thing a constructor
does is call the constructor for its superclasses. This process continues until the
constructor for java.lang.The object is called, as java.lang.The object is the base class
for all objects in java.
4. Before the body of the constructor is executed, all instance variable initializers and
initialization blocks are executed. Then the body of the constructor is executed. Thus,
the constructor for the base class completes first and constructor for the most
derived class completes last.

“So, tell me something about yourself.”

This is a campus placement favorite! Almost every interviewer will kick-start the
interview with this question. In response, you can talk a little about your educational
qualifications, where you were born and brought up, your internship experiences and
projects. Focus on your achievements and skills instead of talking about your
personal life.

“What are your weaknesses?”

Don’t make the mistake of saying you have no weaknesses or that you’re a
perfectionist. The interviewer will be instantly put off by this response. Be honest with
your reply and try to play it in your favor. Emphasize how you’re working towards
overcoming your weaknesses. This will make your interviews at campus placements
go smoother.

“Why do you want to work with us?”

Through this question, the interviewer wants to know how serious you are about the
job. They want to know if this job actually means something to you. Thus, you should
make sure you read the job description as well as the company. This should include
its core values, mission, vision and so on. Through your responses, the interviewer
should know that you’re there for the long run and you will be an asset to the
company.

“Where do you see yourself in the next 5 years?”

This question is aimed at understanding whether your career goal matches the role
you’re interviewing for. The idea of campus placements is to hire fresh and able
talent who will stick with the companies for a long time. The recruiters also want to
assess if you have realistic career goals. Make sure your response keeps these ideas
in mind. Do not use cheesy lines such as ‘sitting in your seat’ or something else like
that. Be honest and practical.

“What are your strengths?”

Campus placements are designed in such a way that students are offered a plethora
of companies to choose from. Campus placements also give the companies a
multitude of students to choose from. Thus, both parties should be at their best to
please each other. Through this question, the interviewers want to know how well
you know yourself. They want you to pitch your candidacy in such a way that they’re
convinced that you’re the best fit for the company.

“Are you planning on studying further?”

This is also a question that you may face during campus placements. This is also a
tricky question. It is best if you respond saying that you are not thinking of doing so
at the moment. But, after gaining a few years of experience you may consider it if
necessary. The interviewer would like to know if you are going to be the kind of
employee who quits within 6 months or a year to “pursue higher studies.”

Even if you don’t get placed during campus placements, it isn’t a big deal. The
experience itself teaches you a lot about what to expect during interviews, what the
interviewers want, etc. Just make sure you plan out your responses in the best way
possible and you will be good to go!