Java Interview Questions from interview bit

Monday, February 13, 2023 11:01 PM

Java Interview Questions for Freshers

1. Why is Java a platform independent language?
Java language was developed in such a way that it does not depend on any hardware or software due to the fact that the compiler compiles
the code and then converts it to platform-independent byte code which can be run on multiple systems.
• The only condition to run that byte code is for the machine to have a runtime environment (JRE) installed in it
2. Why is Java not a pure object oriented language?
Java supports primitive data types - byte, boolean, char, short, int, float, long, and double and hence it is not a pure object oriented
language.
3. Difference between Heap and Stack Memory in java. And how java utilizes this.
Stack memory is the portion of memory that was assigned to every individual program. And it was fixed. On the other hand, Heap memory is
the portion that was not allocated to the java program but it will be available for use by the java program when it is required, mostly during
the runtime of the program.
Java Utilizes this memory as -
• When we write a java program then all the variables, methods, etc are stored in the stack memory.
• And when we create any object in the java program then that object was created in the heap memory. And it was referenced from the
stack memory.
Example- Consider the below java program:
classMain{
publicvoidprintArray(int[] array){
for(inti : array)
System.out.println(i);
}
publicstaticvoidmain(String args[]){
int[] array = newint[10];
printArray(array);
}
}
For this java program. The stack and heap memory occupied by java is -

Main and PrintArray is the method that will be available in the stack area and as well as the variables declared that will also be in the stack
area.
And the Object (Integer Array of size 10) we have created, will be available in the Heap area because that space will be allocated to the
program during runtime.
You can download a PDF version of Java Interview Questions.

Download PDF
4. Can java be said to be the complete object-oriented programming language?
It is not wrong if we claim that java is the complete object-oriented programming language. Because Everything in Java is under the classes.
And we can access that by creating the objects.
But also if we say that java is not a completely object-oriented programming language because it has the support of primitive data types like
int, float, char, boolean, double, etc.
Now for the question: Is java a completely object-oriented programming language? We can say that - Java is not a pure object-oriented
programming language, because it has direct access to primitive data types. And these primitive data types don't directly belong to the
Integer classes.
5. How is Java different from C++?
• C++ is only a compiled language, whereas Java is compiled as well as an interpreted language.
• Java programs are machine-independent whereas a c++ program can run only in the machine in which it is compiled.
• C++ allows users to use pointers in the program. Whereas java doesn’t allow it. Java internally uses pointers.
• C++ supports the concept of Multiple inheritances whereas Java doesn't support this. And it is due to avoiding the complexity of name
ambiguity that causes the diamond problem.
6. Pointers are used in C/ C++. Why does Java not make use of pointers?
Pointers are quite complicated and unsafe to use by beginner programmers. Java focuses on code simplicity, and the usage of pointers can
make it challenging. Pointer utilization can also cause potential errors. Moreover, security is also compromised if pointers are used because
the users can directly access memory with the help of pointers.
Thus, a certain level of abstraction is furnished by not including pointers in Java. Moreover, the usage of pointers can make the procedure of
garbage collection quite slow and erroneous. Java makes use of references as these cannot be manipulated, unlike pointers.
7. What do you understand by an instance variable and a local variable?
Instance variables are those variables that are accessible by all the methods in the class. They are declared outside the methods and inside
the class. These variables describe the properties of an object and remain bound to it at any cost.
All the objects of the class will have their copy of the variables for utilization. If any modification is done on these variables, then only that
instance will be impacted by it, and all other class instances continue to remain unaffected.
Example:
classAthlete{
publicString athleteName;
publicdoubleathleteSpeed;
publicintathleteAge;
}
Local variables are those variables present within a block, function, or constructor and can be accessed only inside them. The utilization of
the variable is restricted to the block scope. Whenever a local variable is declared inside a method, the other class methods don’t have any
knowledge about the local variable.
Example:
publicvoidathlete(){
String athleteName;
doubleathleteSpeed;
intathleteAge;
}
8. What are the default values assigned to variables and instances in java?
• There are no default values assigned to the variables in java. We need to initialize the value before using it. Otherwise, it will throw a
compilation error of (Variable might not be initialized).
• But for instance, if we create the object, then the default value will be initialized by the default constructor depending on the data
type.
• If it is a reference, then it will be assigned to null.
• If it is numeric, then it will assign to 0.
• If it is a boolean, then it will be assigned to false. Etc.
9. What do you mean by data encapsulation?
• Data Encapsulation is an Object-Oriented Programming concept of hiding the data attributes and their behaviours in a single unit.
• It helps developers to follow modularity while developing software by ensuring that each object is independent of other objects by
having its own methods, attributes, and functionalities.
• It is used for the security of the private properties of an object and hence serves the purpose of data hiding.

10. Tell us something about JIT compiler.

• JIT stands for Just-In-Time and it is used for improving the performance during run time. It does the task of compiling parts of byte
code having similar functionality at the same time thereby reducing the amount of compilation time for the code to run.
• The compiler is nothing but a translator of source code to machine-executable code. But what is special about the JIT compiler? Let us
see how it works:
○ First, the Java source code (.java) conversion to byte code (.class) occurs with the help of the javac compiler.
○ Then, the .class files are loaded at run time by JVM and with the help of an interpreter, these are converted to machine
understandable code.
○ JIT compiler is a part of JVM. When the JIT compiler is enabled, the JVM analyzes the method calls in the .class files and compiles
them to get more efficient and native code. It also ensures that the prioritized method calls are optimized.
 ○ Once the above step is done, the JVM executes the optimized code directly instead of interpreting the code again. This increases
the performance and speed of the execution.

11. Can you tell the difference between equals() method and equality operator (==) in Java?
We are already aware of the (==) equals operator. That we have used this to compare the equality of the values. But when we talk about the
terms of object-oriented programming, we deal with the values in the form of objects. And this object may contain multiple types of data. So
using the (==) operator does not work in this case. So we need to go with the .equals() method.
Both [(==) and .equals()] primary functionalities are to compare the values, but the secondary functionality is different.
So in order to understand this better, let’s consider this with the example -
String str1 = "InterviewBit";
String str2 = "InterviewBit";

System.out.println(str1 == str2);
This code will print true. We know that both strings are equals so it will print true. But here (==) Operators don’t compare each character in
this case. It compares the memory location. And because the string uses the constant pool for storing the values in the memory, both str1
and str2 are stored at the same memory location. See the detailed Explanation in Question no 73: Link.

Now, if we modify the program a little bit with -

String str1 = newString("InterviewBit");
String str2 = "InterviewBit";

System.out.println(str1 == str2);
Then in this case, it will print false. Because here no longer the constant pool concepts are used. Here, new memory is allocated. So here the
memory address is different, therefore ( == ) Operator returns false. But the twist is that the values are the same in both strings. So how to
compare the values? Here the .equals() method is used.
.equals() method compares the values and returns the result accordingly. If we modify the above code with -
System.out.println(str1.equals(str2));
Then it returns true.
equals() ==
This is a method defined in the Object class. It is a binary operator in Java.
The .equals() Method is present in the Object class, so we can override It cannot be modified. They always compare the HashCode.
our custom .equals() method in the custom class, for objects
comparison.
This method is used for checking the equality of contents between two This operator is used for comparing addresses (or references), i.e
objects as per the specified business logic. checks if both the objects are pointing to the same memory
location.
Note:
• In the cases where the equals method is not overridden in a class, then the class uses the default implementation of the equals
method that is closest to the parent class.
• Object class is considered as the parent class of all the java classes. The implementation of the equals method in the Object class uses
the == operator to compare two objects. This default implementation can be overridden as per the business logic.
12. How is an infinite loop declared in Java?
Infinite loops are those loops that run infinitely without any breaking conditions. Some examples of consciously declaring infinite loop is:
• Using For Loop:
for(;;)
{
// Business logic// Any break logic}
• Using while loop:
while(true){
// Business logic// Any break logic}
• Using do-while loop:
do{
 // Business logic// Any break logic}while(true);
13. Briefly explain the concept of constructor overloading
Constructor overloading is the process of creating multiple constructors in the class consisting of the same name with a difference in the
constructor parameters. Depending upon the number of parameters and their corresponding types, distinguishing of the different types of
constructors is done by the compiler.
classHospital{
intvariable1, variable2;
doublevariable3;
publicHospital(intdoctors, intnurses){
variable1 = doctors;
variable2 = nurses;
}
publicHospital(intdoctors){
variable1 = doctors;
}
publicHospital(doublesalaries){
variable3 = salaries
}
}

Three constructors are defined here but they differ on the basis of parameter type and their numbers.
14. Define Copy constructor in java.
Copy Constructor is the constructor used when we want to initialize the value to the new object from the old object of the same class.
classInterviewBit{
String department;
String service;
InterviewBit(InterviewBit ib){
this.departments = ib.departments;
this.services = ib.services;
}
}
Here we are initializing the new object value from the old object value in the constructor. Although, this can also be achieved with the help
of object cloning.
15. Can the main method be Overloaded?
Yes, It is possible to overload the main method. We can create as many overloaded main methods we want. However, JVM has a predefined
calling method that JVM will only call the main method with the definition of -
publicstaticvoidmain(string[] args)
Consider the below code snippets:
classMain{
publicstaticvoidmain(String args[]){
System.out.println(" Main Method");
}
publicstaticvoidmain(int[] args){
 System.out.println("Overloaded Integer array Main Method");
}
publicstaticvoidmain(char[] args){
System.out.println("Overloaded Character array Main Method");
}
publicstaticvoidmain(double[] args){
System.out.println("Overloaded Double array Main Method");
}
publicstaticvoidmain(floatargs){
System.out.println("Overloaded float Main Method");
}
}
16. Comment on method overloading and overriding by citing relevant examples.
In Java, method overloading is made possible by introducing different methods in the same class consisting of the same name. Still, all the
functions differ in the number or type of parameters. It takes place inside a class and enhances program readability.
The only difference in the return type of the method does not promote method overloading. The following example will furnish you with a
clear picture of it.
classOverloadingHelp{
publicintfindarea(intl, intb){
intvar1;
var1 = l * b;
returnvar1;
}
publicintfindarea(intl, intb, inth){
intvar2;
var2 = l * b * h;
returnvar2;
}
}

Both the functions have the same name but differ in the number of arguments. The first method calculates the area of the rectangle,
whereas the second method calculates the area of a cuboid.
Method overriding is the concept in which two methods having the same method signature are present in two different classes in which an
inheritance relationship is present. A particular method implementation (already present in the base class) is possible for the derived class by
using method overriding.
Let’s give a look at this example:
classHumanBeing{
publicintwalk(intdistance, inttime){
intspeed = distance / time;
returnspeed;
}
}
classAthleteextendsHumanBeing{
publicintwalk(intdistance, inttime){
 intspeed = distance / time;
speed = speed * 2;
returnspeed;
}
}

Both class methods have the name walk and the same parameters, distance, and time. If the derived class method is called, then the base
class method walk gets overridden by that of the derived class.
17. A single try block and multiple catch blocks can co-exist in a Java Program. Explain.
Yes, multiple catch blocks can exist but specific approaches should come prior to the general approach because only the first catch block
satisfying the catch condition is executed. The given code illustrates the same:
publicclassMultipleCatch{
publicstaticvoidmain(String args[]){
try{
intn = 1000, x = 0;
intarr[] = newint[n];
for(inti = 0; i <= n; i++) {
arr[i] = i / x;
}
}
catch(ArrayIndexOutOfBoundsException exception) {
System.out.println("1st block = ArrayIndexOutOfBoundsException");
}
catch(ArithmeticException exception) {
System.out.println("2nd block = ArithmeticException");
}
catch(Exception exception) {
System.out.println("3rd block = Exception");
}
}
}
Here, the second catch block will be executed because of division by 0 (i / x). In case x was greater than 0 then the first catch block will
execute because for loop runs till i = n and array index are till n-1.
18. Explain the use of final keyword in variable, method and class.
In Java, the final keyword is used as defining something as constant /final and represents the non-access modifier.
• final variable:
○ When a variable is declared as final in Java, the value can’t be modified once it has been assigned.
○ If any value has not been assigned to that variable, then it can be assigned only by the constructor of the class.
• final method:
○ A method declared as final cannot be overridden by its children's classes.
○ A constructor cannot be marked as final because whenever a class is inherited, the constructors are not inherited. Hence,
marking it final doesn't make sense. Java throws compilation error saying - modifier final not allowed here
• final class:
○ No classes can be inherited from the class declared as final. But that final class can extend other classes for its usage.
19. Do final, finally and finalize keywords have the same function?
All three keywords have their own utility while programming.
Final: If any restriction is required for classes, variables, or methods, the final keyword comes in handy. Inheritance of a final class and
overriding of a final method is restricted by the use of the final keyword. The variable value becomes fixed after incorporating the final
keyword. Example:
finalinta=100;
a = 0; // error
The second statement will throw an error.
Finally: It is the block present in a program where all the codes written inside it get executed irrespective of handling of exceptions. Example:
try{
intvariable = 5;
}
catch(Exception exception) {
System.out.println("Exception occurred");
}
finally{
System.out.println("Execution of finally block");
}
Finalize: Prior to the garbage collection of an object, the finalize method is called so that the clean-up activity is implemented. Example:
publicstaticvoidmain(String[] args){
String example = newString("InterviewBit");
example = null;
System.gc(); // Garbage collector called}
publicvoidfinalize(){
// Finalize called}
20. Is it possible that the ‘finally’ block will not be executed? If yes then list the case.
Yes. It is possible that the ‘finally’ block will not be executed. The cases are-
• Suppose we use System.exit() in the above statement.
• If there are fatal errors like Stack overflow, Memory access error, etc.
21. Identify the output of the java program and state the reason.
1.publicclassInterviewBit2. {
3.publicstaticvoidmain(String[] args){
4.finalinti;
5.i = 20;
6.intj = i+20;
7.i = j+30;
8.System.out.println(i + " "+ j);
9.}
10.}
The above code will generate a compile-time error at Line 7 saying - [error: variable i might already have been initialized]. It is because
variable ‘i’ is the final variable. And final variables are allowed to be initialized only once, and that was already done on line no 5.
22. When can you use super keyword?
• The super keyword is used to access hidden fields and overridden methods or attributes of the parent class.
• Following are the cases when this keyword can be used:
○ Accessing data members of parent class when the member names of the class and its child subclasses are same.
○ To call the default and parameterized constructor of the parent class inside the child class.
○ Accessing the parent class methods when the child classes have overridden them.
• The following example demonstrates all 3 cases when a super keyword is used.
publicclassParent{
protectedintnum = 1;

Parent(){
System.out.println("Parent class default constructor.");
}

Parent(String x){
System.out.println("Parent class parameterised constructor.");
}

publicvoidfoo(){
 System.out.println("Parent class foo!");
}
}

publicclassChildextendsParent{
privateintnum = 2;

Child(){
System.out.println("Child class default Constructor");
super("Call Parent"); // to call parameterised constructor.super(); // to call default parent constructor}

voidprintNum(){
System.out.println(num);
System.out.println(super.num); //prints the value of num of parent class}

@Overridepublicvoidfoo(){
System.out.println("Parent class foo!");
super.foo(); //Calls foo method of Parent class inside the Overriden foo method of Child class.}
}
23. Can the static methods be overloaded?
Yes! There can be two or more static methods in a class with the same name but differing input parameters.
24. Why is the main method static in Java?
The main method is always static because static members are those methods that belong to the classes, not to an individual object. So if the
main method will not be static then for every object, It is available. And that is not acceptable by JVM. JVM calls the main method based on
the class name itself. Not by creating the object.
Because there must be only 1 main method in the java program as the execution starts from the main method. So for this reason the main
method is static.
25. Can the static methods be overridden?
• No! Declaration of static methods having the same signature can be done in the subclass but run time polymorphism can not take
place in such cases.
• Overriding or dynamic polymorphism occurs during the runtime, but the static methods are loaded and looked up at the compile time
statically. Hence, these methods cant be overridden.
26. Difference between static methods, static variables, and static classes in java.
• Static Methods and Static variables are those methods and variables that belong to the class of the java program, not to the object of
the class. This gets memory where the class is loaded. And these can directly be called with the help of class names.
○ For example - We have used mathematical functions in the java program like - max(), min(), sqrt(), pow(), etc. And if we notice
that, then we will find that we call it directly with the class name. Like - Math.max(), Math.min(), etc. So that is a static
method. And Similarly static variables we have used like (length) for the array to get the length. So that is the static method.
• Static classes - A class in the java program cannot be static except if it is the inner class. If it is an inner static class, then it exactly works
like other static members of the class.
27. What is the main objective of garbage collection?
The main objective of this process is to free up the memory space occupied by the unnecessary and unreachable objects during the Java
program execution by deleting those unreachable objects.
• This ensures that the memory resource is used efficiently, but it provides no guarantee that there would be sufficient memory for the
program execution.
28. What is a ClassLoader?
• Java Classloader is the program that belongs to JRE (Java Runtime Environment). The task of ClassLoader is to load the required classes
and interfaces to the JVM when required.
• Example- To get input from the console, we require the scanner class. And the Scanner class is loaded by the ClassLoader.
29. What part of memory - Stack or Heap - is cleaned in garbage collection process?
Heap.
30. What are shallow copy and deep copy in java?
To copy the object's data, we have several methods like deep copy and shallow copy.
Example -
classRectangle{
intlength = 5;
intbreadth = 3;
}
Object for this Rectangle class - Rectangle obj1 = new Rectangle();
• Shallow copy - The shallow copy only creates a new reference and points to the same object. Example - For Shallow copy, we can do
this by -
Rectangle obj2 = obj1;
Now by doing this what will happen is the new reference is created with the name obj2 and that will point to the same memory location.
• Deep Copy - In a deep copy, we create a new object and copy the old object value to the new object. Example -
Rectangle obj3 = newRectangle();
Obj3.length = obj1.length;
Obj3.breadth = obj1.breadth;
Both these objects will point to the memory location as stated below -

Now, if we change the values in shallow copy then they affect the other reference as well. Let's see with the help of an example -
classRectangle{
intlength = 5;
intbreadth = 3;
}
publicclassMain{
publicstaticvoidmain(String[] args){
Rectangle obj1 = newRectangle();
//Shallow CopyRectangle obj2 = obj1;

System.out.println(" Before Changing the value of object 1, the object2 will be - ");
System.out.println(" Object2 Length = "+obj2.length+", Object2 Breadth = "+obj2.breadth);

//Changing the values for object1.obj1.length = 10;

obj1.breadth = 20;

System.out.println("\n After Changing the value of object 1, the object2 will be - ");
System.out.println(" Object2 Length = "+obj2.length+", Object2 Breadth = "+obj2.breadth);

}
}
Output -
Before Changing the value of object 1, the object2 will be -
Object2 Length = 5, Object2 Breadth = 3After Changing the value of object 1, the object2 will be -
Object2 Length = 10, Object2 Breadth = 20
We can see that in the above code, if we change the values of object1, then the object2 values also get changed. It is because of the
reference.
Now, if we change the code to deep copy, then there will be no effect on object2 if it is of type deep copy. Consider some snippets to be
added in the above code.
classRectangle{
intlength = 5;
intbreadth = 3;
}
publicclassMain{
publicstaticvoidmain(String[] args){
Rectangle obj1 = newRectangle();
//Shallow CopyRectangle obj2 = newRectangle();
obj2.length = obj1.length;
obj2.breadth = obj1.breadth;

System.out.println(" Before Changing the value of object 1, the object2 will be - ");
System.out.println(" Object2 Length = "+obj2.length+", Object2 Breadth = "+obj2.breadth);

//Changing the values for object1.obj1.length = 10;

obj1.breadth = 20;

System.out.println("\n After Changing the value of object 1, the object2 will be - ");
System.out.println(" Object2 Length = "+obj2.length+", Object2 Breadth = "+obj2.breadth);

}
}
The above snippet will not affect the object2 values. It has its separate values. The output will be
Before Changing the value of object 1, the object2 will be -
Object2 Length = 5, Object2 Breadth = 3After Changing the value of object 1, the object2 will be -
Object2 Length = 5, Object2 Breadth = 3
Now we see that we need to write the number of codes for this deep copy. So to reduce this, In java, there is a method called clone().
The clone() will do this deep copy internally and return a new object. And to do this we need to write only 1 line of code. That is - Rectangle
obj2 = obj1.clone();
Java Intermediate Interview Questions
31. Apart from the security aspect, what are the reasons behind making strings immutable in
Java?
A String is made immutable due to the following reasons:
• String Pool: Designers of Java were aware of the fact that String data type is going to be majorly used by the programmers and
developers. Thus, they wanted optimization from the beginning. They came up with the notion of using the String pool (a storage area
in Java heap) to store the String literals. They intended to decrease the temporary String object with the help of sharing. An immutable
class is needed to facilitate sharing. The sharing of the mutable structures between two unknown parties is not possible. Thus,
immutable Java String helps in executing the concept of String Pool.

• Multithreading: The safety of threads regarding the String objects is an important aspect in Java. No external synchronization is
required if the String objects are immutable. Thus, a cleaner code can be written for sharing the String objects across different threads.
The complex process of concurrency is facilitated by this method.
• Collections: In the case of Hashtables and HashMaps, keys are String objects. If the String objects are not immutable, then it can get
modified during the period when it resides in the HashMaps. Consequently, the retrieval of the desired data is not possible. Such
changing states pose a lot of risks. Therefore, it is quite safe to make the string immutable.
32. What is a singleton class in Java? And How to implement a singleton class?
Singleton classes are those classes, whose objects are created only once. And with only that object the class members can be accessed.
Understand this with the help of an example-:
Consider the water jug in the office and if every employee wants that water then they will not create a new water jug for drinking water.
They will use the existing one with their own reference as a glass. So programmatically it should be implemented as -
classWaterJug{
privateintwaterQuantity = 500;
 privateWaterJug(){}
privateWaterJug object = null;

// Method to provide the service of Giving Water.publicintgetWater(intquantity){

waterQuantity -= quantity;
returnquantity;
}
// Method to return the object to the user.publicstaticWaterjug getInstance(){
// Will Create a new object if the object is not already created and return the object.if(object == null){
object = newWaterJug();
}
returnobject;
}
}
In the above class, the Constructor is private so we cannot create the object of the class. But we can get the object by calling the method
getInstance(). And the getInstance is static so it can be called without creating the object. And it returns the object. Now with that object,
we can call getWater() to get the water.
Waterjug glass1 = WaterJug.getInstance();
glass1.getWater(1);
We can get the single object using this getInstance(). And it is static, so it is a thread-safe singleton class. Although there are many ways to
create a thread-safe singleton class. So thread-safe classes can also be:
• When singletons are written with double-checked locking, they can be thread-safe.
• We can use static singletons that are initialized during class loading. Like we did in the above example.
• But the most straightforward way to create a thread-safe singleton is to use Java enums.
33. Which of the below generates a compile-time error? State the reason.
1. int[] n1 = new int[0];
2. boolean[] n2 = new boolean[-200];
3. double[] n3 = new double[2241423798];
4. char[] ch = new char[20];
We get a compile-time error in line 3. The error we will get in Line 3 is - integer number too large. It is because the array requires size as an
integer. And Integer takes 4 Bytes in the memory. And the number (2241423798) is beyond the capacity of the integer. The maximum array
size we can declare is - (2147483647).
Because the array requires the size in integer, none of the lines (1, 2, and 4) will give a compile-time error. The program will compile fine. But
we get the runtime exception in line 2. The exception is - NegativeArraySizeException.
Here what will happen is - At the time when JVM will allocate the required memory during runtime then it will find that the size is negative.
And the array size can’t be negative. So the JVM will throw the exception.
34. How would you differentiate between a String, StringBuffer, and a StringBuilder?
• Storage area: In string, the String pool serves as the storage area. For StringBuilder and StringBuffer, heap memory is the storage area.
• Mutability: A String is immutable, whereas both the StringBuilder and StringBuffer are mutable.
• Efficiency: It is quite slow to work with a String. However, StringBuilder is the fastest in performing operations. The speed of a
StringBuffer is more than a String and less than a StringBuilder. (For example appending a character is fastest in StringBuilder and very
slow in String because a new memory is required for the new String with appended character.)
• Thread-safe: In the case of a threaded environment, StringBuilder and StringBuffer are used whereas a String is not used. However,
StringBuilder is suitable for an environment with a single thread, and a StringBuffer is suitable for multiple threads.
Syntax:
// StringString first = "InterviewBit";
String second = newString("InterviewBit");
// StringBufferStringBuffer third = newStringBuffer("InterviewBit");
// StringBuilderStringBuilder fourth = newStringBuilder("InterviewBit");
35. Using relevant properties highlight the differences between interfaces and abstract classes.
• Availability of methods: Only abstract methods are available in interfaces, whereas non-abstract methods can be present along with
abstract methods in abstract classes.
• Variable types: Static and final variables can only be declared in the case of interfaces, whereas abstract classes can also have non-
static and non-final variables.
• Inheritance: Multiple inheritances are facilitated by interfaces, whereas abstract classes do not promote multiple inheritances.
• Data member accessibility: By default, the class data members of interfaces are of the public- type. Conversely, the class members for
an abstract class can be protected or private also.
• Implementation: With the help of an abstract class, the implementation of an interface is easily possible. However, the converse is not
true;
Abstract class example:
publicabstractclassAthlete{
publicabstractvoidwalk();
}
Interface example:
publicinterfaceWalkable{
voidwalk();
}
36. Is this program giving a compile-time error? If Yes then state the reason and number of
errors it will give. If not then state the reason.
abstractfinalclassInterviewBit{
2.publicabstractvoidprintMessage();
3.}
4.classScalarAcademyextendsInterviewBit{
5.publicvoidprintMessage(){
6.System.out.println("Welcome to Scalar Academy By InterviewBit");
7.}
8.}
9.classScalarTopicsextendsScalarAcademy{
10.publicvoidprintMessage(){
11.System.out.println("Welcome to Scalar Topics By Scalar Academy");
12.}
13.}
publicclassMain{
publicstaticvoidmain(String[] args){
InterviewBit ib = newScalarTopics();
ib.printMessage();
}
}
The above program will give a compile-time error. The compiler will throw 2 errors in this.
• [Illegal Combination of modifiers: abstract and final] at line 1.
• [Cannot inherit from final ‘InterviewBit’] at line 4.
It is because abstract classes are incomplete classes that need to be inherited for making their concrete classes. And on the other hand, the
final keywords in class are used for avoiding inheritance. So these combinations are not allowed in java.
37. What is a Comparator in java?
Consider the example where we have an ArrayList of employees like( EId, Ename, Salary), etc. Now if we want to sort this list of employees
based on the names of employees. Then that is not possible to sort using the Collections.sort() method. We need to provide something to
the sort() function depending on what values we have to perform sorting. Then in that case a comparator is used.
Comparator is the interface in java that contains the compare method. And by overloading the compare method, we can define that on what
basis we need to compare the values.
38. In Java, static as well as private method overriding is possible. Comment on the statement.
The statement in the context is completely False. The static methods have no relevance with the objects, and these methods are of the class
level. In the case of a child class, a static method with a method signature exactly like that of the parent class can exist without even
throwing any compilation error.
The phenomenon mentioned here is popularly known as method hiding, and overriding is certainly not possible. Private method overriding is
unimaginable because the visibility of the private method is restricted to the parent class only. As a result, only hiding can be facilitated and
not overriding.
39. What makes a HashSet different from a TreeSet?
Although both HashSet and TreeSet are not synchronized and ensure that duplicates are not present, there are certain properties that
distinguish a HashSet from a TreeSet.
• Implementation: For a HashSet, the hash table is utilized for storing the elements in an unordered manner. However, TreeSet makes
use of the red-black tree to store the elements in a sorted manner.
• Complexity/ Performance: For adding, retrieving, and deleting elements, the time amortized complexity is O(1) for a HashSet. The
time complexity for performing the same operations is a bit higher for TreeSet and is equal to O(log n). Overall, the performance of
HashSet is faster in comparison to TreeSet.
• Methods: hashCode() and equals() are the methods utilized by HashSet for making comparisons between the objects. Conversely,
compareTo() and compare() methods are utilized by TreeSet to facilitate object comparisons.
• Objects type: Heterogeneous and null objects can be stored with the help of HashSet. In the case of a TreeSet, runtime exception
occurs while inserting heterogeneous objects or null objects.
40. Why is the character array preferred over string for storing confidential information?
In Java, a string is basically immutable i.e. it cannot be modified. After its declaration, it continues to stay in the string pool as long as it is not
removed in the form of garbage. In other words, a string resides in the heap section of the memory for an unregulated and unspecified time
interval after string value processing is executed.
As a result, vital information can be stolen for pursuing harmful activities by hackers if a memory dump is illegally accessed by them. Such
risks can be eliminated by using mutable objects or structures like character arrays for storing any variable. After the work of the character
array variable is done, the variable can be configured to blank at the same instant. Consequently, it helps in saving heap memory and also
gives no chance to the hackers to extract vital data.
41. What do we get in the JDK file?
• JDK- For making java programs, we need some tools that are provided by JDK (Java Development Kit). JDK is the package that contains
various tools, Compiler, Java Runtime Environment, etc.
• JRE - To execute the java program we need an environment. (Java Runtime Environment) JRE contains a library of Java classes + JVM.
What are JAVA Classes? It contains some predefined methods that help Java programs to use that feature, build and execute. For
example - there is a system class in java that contains the print-stream method, and with the help of this, we can print something on
the console.
• JVM - (Java Virtual Machine) JVM is a part of JRE that executes the Java program at the end. Actually, it is part of JRE, but it is
software that converts bytecode into machine-executable code to execute on hardware.

42. What are the differences between JVM, JRE and JDK in Java?
Criteria JDK JRE JVM
Abbrevia Java Development Kit Java Runtime Environment Java Virtual Machine
tion
Definitio JDK is a complete software JRE is a software package JVM is a platform-dependent, abstract machine comprising of 3
n development kit for developing providing Java class libraries, specifications - document describing the JVM implementation
Java applications. It comprises JVM and all the required requirements, computer program meeting the JVM
JRE, JavaDoc, compiler, components to run the Java requirements and instance object for executing the Java byte
debuggers, etc. applications. code and provide the runtime environment for execution.
Main JDK is mainly used for code JRE is mainly used for JVM provides specifications for all the implementations to JRE.
Purpose development and execution. environment creation to
execute the code.
Tools JDK provides tools like JRE provides libraries and JVM does not include any tools, but instead, it provides the
provided compiler, debuggers, etc for classes required by JVM to specification for implementation.
code development run the program.
Summar JDK = (JRE) + Development JRE = (JVM) + Libraries to JVM = Runtime environment to execute Java byte code.
y tools execute the application

43. What are the differences between HashMap and HashTable in Java?
HashMap HashTable
HashMap is not synchronized thereby making it better for non-threaded HashTable is synchronized and hence it is suitable for threaded
applications. applications.
Allows only one null key but any number of null in the values. This does not allow null in both keys or values.
Supports order of insertion by making use of its subclass Order of insertion is not guaranteed in HashTable.
LinkedHashMap.

44. What is the importance of reflection in Java?

• The term reflection is used for describing the inspection capability of a code on other code either of itself or of its system and modify it
 during runtime.
• Consider an example where we have an object of unknown type and we have a method ‘fooBar()’ which we need to call on the object.
The static typing system of Java doesn't allow this method invocation unless the type of the object is known beforehand. This can be
achieved using reflection which allows the code to scan the object and identify if it has any method called “fooBar()” and only then call
the method if needed.
Method methodOfFoo = fooObject.getClass().getMethod("fooBar", null);
methodOfFoo.invoke(fooObject, null);
• Using reflection has its own cons:
○ Speed — Method invocations due to reflection are about three times slower than the direct method calls.
○ Type safety — When a method is invoked via its reference wrongly using reflection, invocation fails at runtime as it is not
detected at compile/load time.
○ Traceability — Whenever a reflective method fails, it is very difficult to find the root cause of this failure due to a huge stack
trace. One has to deep dive into the invoke() and proxy() method logs to identify the root cause.
• Hence, it is advisable to follow solutions that don't involve reflection and use this method as a last resort.
45. What are the different ways of threads usage?
• We can define and implement a thread in java using two ways:
○ Extending the Thread class
classInterviewBitThreadExampleextendsThread{
publicvoidrun(){
System.out.println("Thread runs...");
}
publicstaticvoidmain(String args[]){
InterviewBitThreadExample ib = newInterviewBitThreadExample();
ib.start();
}
}
• Implementing the Runnable interface
classInterviewBitThreadExampleimplementsRunnable{
publicvoidrun(){
System.out.println("Thread runs...");
}
publicstaticvoidmain(String args[]){
Thread ib = newThread(newInterviewBitThreadExample());
ib.start();
}
}
• Implementing a thread using the method of Runnable interface is more preferred and advantageous as Java does not have support for
multiple inheritances of classes.
• start() method is used for creating a separate call stack for the thread execution. Once the call stack is created, JVM calls the run()
method for executing the thread in that call stack.
46. What are the different types of Thread Priorities in Java? And what is the default priority of
a thread assigned by JVM?
There are a total of 3 different types of priority available in Java.
MIN_PRIORITY: It has an integer value assigned with 1.
MAX_PRIORITY: It has an integer value assigned with 10.
NORM_PRIORITY: It has an integer value assigned with 5.
In Java, Thread with MAX_PRIORITY gets the first chance to execute. But the default priority for any thread is NORM_PRIORITY assigned by
JVM.
47. What is the difference between the program and the process?
• A program can be defined as a line of code written in order to accomplish a particular task. Whereas the process can be defined as the
programs which are under execution.
• A program doesn't execute directly by the CPU. First, the resources are allocated to the program and when it is ready for execution
then it is a process.
48. What is the difference between the ‘throw’ and ‘throws’ keyword in java?
• The ‘throw’ keyword is used to manually throw the exception to the calling method.
• And the ‘throws’ keyword is used in the function definition to inform the calling method that this method throws the exception. So if
you are calling, then you have to handle the exception.
Example -
classMain{
 publicstaticinttestExceptionDivide(inta, intb)throwsArithmeticException{
if(a == 0|| b == 0)
thrownewArithmeticException();
returna/b;
}
publicstaticvoidmain(String args[]){
try{
testExceptionDivide(10, 0);
}
catch(ArithmeticException e){
//Handle the exception}
}
}
Here in the above snippet, the method testExceptionDivide throws an exception. So if the main method is calling it then it must have
handled the exception. Otherwise, the main method can also throw the exception to JVM.
And the method testExceptionDivide 'throws’ the exception based on the condition.
49. What are the differences between constructor and method of a class in Java?
Constructor Method
Constructor is used for initializing the object state. Method is used for exposing the object's
behavior.
Constructor has no return type. Method should have a return type. Even if it does
not return anything, return type is void.
Constructor gets invoked implicitly. Method has to be invoked on the object explicitly.
If the constructor is not defined, then a default constructor is provided by the java If a method is not defined, then the compiler does
compiler. not provide it.
The constructor name should be equal to the class name. The name of the method can have any name or
have a class name too.
A constructor cannot be marked as final because whenever a class is inherited, the A method can be defined as final but it cannot be
constructors are not inherited. Hence, marking it final doesn't make sense. Java throws overridden in its subclasses.
compilation error saying - modifier final not allowed here
Final variable instantiations are possible inside a constructor and the scope of this A final variable if initialised inside a method
applies to the whole class and its objects. ensures that the variable cant be changed only
within the scope of that method.

50. Identify the output of the below java program and Justify your answer.
classMain{
publicstaticvoidmain(String args[]){
Scaler s = newScaler(5);
}
}
classInterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
classScalerextendsInterviewBit{
Scaler(){
System.out.println(" Welcome to Scaler Academy ");
}
Scaler(intx){
this();
super();
System.out.println(" Welcome to Scaler Academy 2");
}
}
The above code will throw the compilation error. It is because the super() is used to call the parent class constructor. But there is the
condition that super() must be the first statement in the block. Now in this case, if we replace this() with super() then also it will throw the
compilation error. Because this() also has to be the first statement in the block. So in conclusion, we can say that we cannot use this() and
super() keywords in the same block.
51. Java works as “pass by value” or “pass by reference” phenomenon?
Java always works as a “pass by value”. There is nothing called a “pass by reference” in Java. However, when the object is passed in any
method, the address of the value is passed due to the nature of object handling in Java. When an object is passed, a copy of the reference is
created by Java and that is passed to the method. The objects point to the same memory location. 2 cases might happen inside the method:
• Case 1: When the object is pointed to another location: In this case, the changes made to that object do not get reflected the original
object before it was passed to the method as the reference points to another location.
For example:
classInterviewBitTest{
intnum;
InterviewBitTest(intx){
num = x;
}
InterviewBitTest(){
num = 0;
}
}
classDriver{
publicstaticvoidmain(String[] args){
//create a referenceInterviewBitTest ibTestObj = newInterviewBitTest(20);
//Pass the reference to updateObject MethodupdateObject(ibTestObj);
//After the updateObject is executed, check for the value of num in the object.System.out.println(ibTestObj.num);
}
publicstaticvoidupdateObject(InterviewBitTest ibObj){
// Point the object to new referenceibObj = newInterviewBitTest();
// Update the value ibObj.num = 50;
}
}
Output:
20
• Case 2: When object references are not modified: In this case, since we have the copy of reference the main object pointing to the
same memory location, any changes in the content of the object get reflected in the original object.
For example:
classInterviewBitTest{
intnum;
InterviewBitTest(intx){
num = x;
}
InterviewBitTest(){
num = 0;
}
}
classDriver{
publicstaticvoidmain(String[] args){
//create a referenceInterviewBitTest ibTestObj = newInterviewBitTest(20);
//Pass the reference to updateObject MethodupdateObject(ibTestObj);
//After the updateObject is executed, check for the value of num in the object.System.out.println(ibTestObj.num);
}
publicstaticvoidupdateObject(InterviewBitTest ibObj){
// no changes are made to point the ibObj to new location// Update the value of numibObj.num = 50;
}
}
Output:
50
52. What is the ‘IS-A ‘ relationship in OOPs java?
‘IS-A’ relationship is another name for inheritance. When we inherit the base class from the derived class, then it forms a relationship
between the classes. So that relationship is termed an ‘IS-A’ Relationship.
Example - Consider a Television (Typical CRT TV). Now another Smart TV that is inherited from television class. So we can say that the Smart
iv is also a TV. Because CRT TV things can also be done in the Smart TV.
So here ‘IS-A’ Relationship formed. [ SmartTV ‘IS-A’ TV ].
53. Which among String or String Buffer should be preferred when there are lot of updates
required to be done in the data?
StringBuffer is mutable and dynamic in nature whereas String is immutable. Every updation / modification of String creates a new String
thereby overloading the string pool with unnecessary objects. Hence, in the cases of a lot of updates, it is always preferred to use
StringBuffer as it will reduce the overhead of the creation of multiple String objects in the string pool.
54. How to not allow serialization of attributes of a class in Java?
• In order to achieve this, the attribute can be declared along with the usage of transient keyword as shown below:
publicclassInterviewBitExample{
privatetransientString someInfo;
privateString name;
privateintid;
// :// Getters setters// :}
• In the above example, all the fields except someInfo can be serialized.
55. What happens if the static modifier is not included in the main method signature in Java?
There wouldn't be any compilation error. But then the program is run, since the JVM cant map the main method signature, the code throws
“NoSuchMethodError” error at the runtime.
56. Consider the below program, identify the output, and also state the reason for that.
publicclassMain{
publicstaticvoidmain(String[] args){
System.out.println(" Hello. Main Method. ");
}
publicstaticvoidmain(int[] args){
System.out.println(" Hello. Main Method2. ");
}
}
The output of the above program will be Hello. Main Method. This is because JVM will always call the main method based on the definition
it already has. Doesn't matter how many main methods we overload it will only execute one main method based on its declaration in JVM.
57. Can we make the main() thread a daemon thread?
In java multithreading, the main() threads are always non-daemon threads. And there is no way we can change the nature of the non-
daemon thread to the daemon thread.
58. What happens if there are multiple main methods inside one class in Java?
The program can't compile as the compiler says that the method has been already defined inside the class.
59. What do you understand by Object Cloning and how do you achieve it in Java?
• It is the process of creating an exact copy of any object. In order to support this, a java class has to implement the Cloneable interface
of java.lang package and override the clone() method provided by the Object class the syntax of which is:
protectedObject clone()throwsCloneNotSupportedException{
return(Object)super.clone();
}
• In case the Cloneable interface is not implemented and just the method is overridden, it results in CloneNotSupportedException in
Java.
60. How does an exception propagate in the code?
When an exception occurs, first it searches to locate the matching catch block. In case, the matching catch block is located, then that block
would be executed. Else, the exception propagates through the method call stack and goes into the caller method where the process of
matching the catch block is performed. This propagation happens until the matching catch block is found. If the match is not found, then the
program gets terminated in the main method.
61. How do exceptions affect the program if it doesn't handle them?
Exceptions are runtime errors. Suppose we are making an android application with java. And it all works fine but there is an exceptional case
when the application tries to get the file from storage and the file doesn’t exist (This is the case of exception in java). And if this case is not
handled properly then the application will crash. This will be a bad experience for users. This is the type of error that cannot be controlled
by the programmer. But programmers can take some steps to avoid this so that the application won’t crash. The proper action can be taken
at this step.
62. Is it mandatory for a catch block to be followed after a try block?
No, it is not necessary for a catch block to be present after a try block. - A try block should be followed either by a catch block or by a finally
block. If the exceptions likelihood is more, then they should be declared using the throws clause of the method.
63. Will the finally block get executed when the return statement is written at the end of try
block and catch block as shown below?
publicintsomeMethod(inti){
try{
//some statementreturn1;
}catch(Exception e){
//some statementreturn999;
}finally{
//finally block statements}
}
finally block will be executed irrespective of the exception or not. The only case where finally block is not executed is when it encounters
‘System.exit()’ method anywhere in try/catch block.
64. Can you call a constructor of a class inside the another constructor?
Yes, the concept can be termed as constructor chaining and can be achieved using this().

65. Contiguous memory locations are usually used for storing actual values in an array but not
in ArrayList. Explain.
In the case of ArrayList, data storing in the form of primitive data types (like int, float, etc.) is not possible. The data members/objects
present in the ArrayList have references to the objects which are located at various sites in the memory. Thus, storing of actual objects or
non-primitive data types (like Integer, Double, etc.) takes place in various memory locations.

However, the same does not apply to the arrays. Object or primitive type values can be stored in arrays in contiguous memory locations,
hence every element does not require any reference to the next element.

66. Why does the java array index start with 0?

It is because the 0 index array avoids the extra arithmetic operation to calculate the memory address.
Example - Consider the array and assume each element takes 4-byte memory space. Then the address will be like this -

Now if we want to access index 4. Then internally java calculates the address using the formula-
[Base Address + (index * no_of_bytes)]. So according to this. The starting address of the index 4 will be - [100 + (4*4)] = 116. And exactly
that's what the address is calculated.
Now consider the same with 1 index Array -

Now if we apply the same formula here. Then we get - 116 as the starting address of the 4th index. Which is wrong. Then we need to apply
formula - [Base Address + ((index-1) * no_of_bytes)].
And for calculating this, an extra arithmetic operation has to be performed. And consider the case where millions of addresses need to be
calculated, this causes complexity. So to avoid this, ) the index array is supported by java.
67. Why is the remove method faster in the linked list than in an array?
In the linked list, we only need to adjust the references when we want to delete the element from either end or the front of the linked list.
But in the array, indexes are used. So to manage proper indexing, we need to adjust the values from the array So this adjustment of value is
costlier than the adjustment of references.
Example - To Delete from the front of the linked list, internally the references adjustments happened like this.

The only thing that will change is that the head pointer will point to the head’s next node. And delete the previous node. That is the constant
time operation.
Whereas in the ArrayList, internally it should work like this-

For deletion of the first element, all the next element has to move to one place ahead. So this copying value takes time. So that is the reason
why removing in ArrayList is slower than LinkedList.
68. How many overloaded add() and addAll() methods are available in the List interface?
Describe the need and uses.
There are a total of 4 overloaded methods for add() and addAll() methods available in List Interface. The below table states the description
of all.
Return Method Description
Type
boolean add(Element e): This method is used for adding the element at the end of the List. The Datatype of the element is of any type it
has been initially assigned with. It returns the boolean indicating successfully inserted or not.
void add(int index, Element e): This method is the overloaded version of add() method. In this, along with the element, the index is
also passed to the method for the specific index the value needs to be inserted.
boolean addAll(Collection <extends ? Element > c): This method helps to add all elements at the end of collections from the list received
in the parameter. It contains an iterator that helps to iterate the list and add the elements to the collection.
boolean addAll(int index, Collection <extends ? Element > c): This is the overloaded method for addAll() method. In this along with the
list, we can pass the specified index from which the list elements need to be added.

69. How does the size of ArrayList grow dynamically? And also state how it is implemented
internally.
ArrayList is implemented in such a way that it can grow dynamically. We don't need to specify the size of ArrayList. For adding the values in
it, the methodology it uses is -
1. Consider initially that there are 2 elements in the ArrayList. [2, 3].

2. If we need to add the element into this. Then internally what will happen is-
• ArrayList will allocate the new ArrayList of Size (current size + half of the current size). And add the old elements into the new. Old - [2,
3], New - [2, 3, null, null].

• Then the new value will be inserted into it. [2, 3, 4, null]. And for the next time, the extra space will be available for the value to be
inserted.

3. This process continues and the time taken to perform all of these is considered as the amortized constant time.
This is how the ArrayList grows dynamically. And when we delete any entry from the ArrayList then the following steps are performed -
1. It searches for the element index in the array. Searching takes some time. Typically it’s O(n) because it needs to search for the element in
the entire array.
2. After searching the element, it needs to shift the element from the right side to fill the index.

So this is how the elements are deleted from the ArrayList internally. Similarly, the search operations are also implemented internally as
defined in removing elements from the list (searching for elements to delete).
Java Interview Questions for Experienced
70. Although inheritance is a popular OOPs concept, it is less advantageous than composition.
Explain.
Inheritance lags behind composition in the following scenarios:
• Multiple-inheritance is not possible in Java. Classes can only extend from one superclass. In cases where multiple functionalities are
required, for example - to read and write information into the file, the pattern of composition is preferred. The writer, as well as
reader functionalities, can be made use of by considering them as the private members.
• Composition assists in attaining high flexibility and prevents breaking of encapsulation.
• Unit testing is possible with composition and not inheritance. When a developer wants to test a class composing a different class, then
Mock Object can be created for signifying the composed class to facilitate testing. This technique is not possible with the help of
inheritance as the derived class cannot be tested without the help of the superclass in inheritance.
• The loosely coupled nature of composition is preferable over the tightly coupled nature of inheritance.
Let’s take an example:
packagecomparison;
publicclassTop{
publicintstart(){
return0;
}
}
classBottomextendsTop{
publicintstop(){
return0;
}
}
In the above example, inheritance is followed. Now, some modifications are done to the Top class like this:
publicclassTop{
publicintstart(){
return0;
}
publicvoidstop(){
}
}
If the new implementation of the Top class is followed, a compile-time error is bound to occur in the Bottom class. Incompatible return type
is there for the Top.stop() function. Changes have to be made to either the Top or the Bottom class to ensure compatibility. However, the
composition technique can be utilized to solve the given problem:
classBottom{
Top par = newTop();
publicintstop(){
par.start();
par.stop();
return0;
}
}
71. What is the difference between ‘>>’ and ‘>>>’ operators in java?
These 2 are the bitwise right shift operators. Although both operators look similar. But there is a minimal difference between these two right
shift operators.
• ‘>>’ Bitwise Right Shift Operator- This operator shifts each bit to its right position. And this maintains the signed bit.
 • ‘>>>’ Bitwise Right Shift Operator with trailing zero- This operator also shifts each bit to its right. But this doesn’t maintain the signed
bit. This operator makes the Most significant bit to 0.
Example- Num1 = 8, Num2 = -8.
So the binary form of these numbers are -
Num1 = 00000000 00000000 00000000 00001000
Num2 = 11111111 11111111 11111111 11111000
‘>>’ Operator : 8 >> 1 (Shift by one bit) :
Num1 = 00000000 00000000 00000000 00000100
Num2 = 11111111 11111111 11111111 11111100
‘>>>’ Operator : 8 >>> 1 (Shift by one bit) =
Num1 = 00000000 00000000 00000000 00000100
Num2 = 01111111 11111111 11111111 11111100
72. What are Composition and Aggregation? State the difference.
Composition, and Aggregation help to build (Has - A - Relationship) between classes and objects. But both are not the same in the end. Let’s
understand with the help of an example.
• Consider the University as a class that has some departments in it. So the university will be the container object. And departments in it
will contain objects. Now in this case, if the container object destroys then the contained objects will also get destroyed
automatically. So here we can say that there is a strong association between the objects. So this Strong Association is called
Composition.
• Now consider one more example. Suppose we have a class department and there are several professors' objects there in the
department. Now if the department class is destroyed then the professor's object will become free to bind with other objects. Because
container objects (Department) only hold the references of contained objects (Professor’s). So here is the weak association between
the objects. And this weak association is called Aggregation.
73. How is the creation of a String using new() different from that of a literal?
When a String is formed as a literal with the assistance of an assignment operator, it makes its way into the String constant pool so that
String Interning can take place. This same object in the heap will be referenced by a different String if the content is the same for both of
them.
publicbool checking(){
String first = "InterviewBit";
String second = "InterviewBit";
if(first == second)
returntrue;
elsereturnfalse;
}
The checking() function will return true as the same content is referenced by both the variables.

Conversely, when a String formation takes place with the help of a new() operator, interning does not take place. The object gets created in
the heap memory even if the same content object is present.
publicbool checking(){
String first = newString("InterviewBit");
String second = newString("InterviewBit");
if(first == second)
returntrue;
elsereturnfalse;
}
The checking() function will return false as the same content is not referenced by both the variables.
74. How is the ‘new’ operator different from the ‘newInstance()’ operator in java?
Both ‘new’ and ‘newInstance()’ operators are used to creating objects. The difference is- that when we already know the class name for
which we have to create the object then we use a new operator. But suppose we don’t know the class name for which we need to create the
object, Or we get the class name from the command line argument, or the database, or the file. Then in that case we use the ‘newInstance()’
operator.
The ‘newInstance()’ keyword throws an exception that we need to handle. It is because there are chances that the class definition doesn’t
exist, and we get the class name from runtime. So it will throw an exception.
75. Is exceeding the memory limit possible in a program despite having a garbage collector?
Yes, it is possible for the program to go out of memory in spite of the presence of a garbage collector. Garbage collection assists in
recognizing and eliminating those objects which are not required in the program anymore, in order to free up the resources used by them.
In a program, if an object is unreachable, then the execution of garbage collection takes place with respect to that object. If the amount of
memory required for creating a new object is not sufficient, then memory is released for those objects which are no longer in the scope with
the help of a garbage collector. The memory limit is exceeded for the program when the memory released is not enough for creating new
objects.
Moreover, exhaustion of the heap memory takes place if objects are created in such a manner that they remain in the scope and consume
memory. The developer should make sure to dereference the object after its work is accomplished. Although the garbage collector
endeavors its level best to reclaim memory as much as possible, memory limits can still be exceeded.
Let’s take a look at the following example:
List<String> example = newLinkedList<String>();
while(true){
example.add(newString("Memory Limit Exceeded"));
}
76. Why is synchronization necessary? Explain with the help of a relevant example.
Concurrent execution of different processes is made possible by synchronization. When a particular resource is shared between many
threads, situations may arise in which multiple threads require the same shared resource.
Synchronization assists in resolving the issue and the resource is shared by a single thread at a time. Let’s take an example to understand it
more clearly. For example, you have a URL and you have to find out the number of requests made to it. Two simultaneous requests can
make the count erratic.
No synchronization:
packageanonymous;
publicclassCounting{
privateintincrease_counter;
publicintincrease(){
increase_counter = increase_counter + 1;
returnincrease_counter;
}
}
If a thread Thread1 views the count as 10, it will be increased by 1 to 11. Simultaneously, if another thread Thread2 views the count as 10, it
will be increased by 1 to 11. Thus, inconsistency in count values takes place because the expected final value is 12 but the actual final value
we get will be 11.
Now, the function increase() is made synchronized so that simultaneous accessing cannot take place.
With synchronization:
packageanonymous;
publicclassCounting{
privateintincrease_counter;
publicsynchronizedintincrease(){
increase_counter = increase_counter + 1;
returnincrease_counter;
}
}

If a thread Thread1 views the count as 10, it will be increased by 1 to 11, then the thread Thread2 will view the count as 11, it will be
increased by 1 to 12. Thus, consistency in count values takes place.
77. In the given code below, what is the significance of ... ?
publicvoidfooBarMethod(String... variables){
// method code}
• Ability to provide ... is a feature called varargs (variable arguments) which was introduced as part of Java 5.
• The function having ... in the above example indicates that it can receive multiple arguments of the datatype String.
• For example, the fooBarMethod can be called in multiple ways and we can still have one method to process the data as shown below:
fooBarMethod("foo", "bar");
fooBarMethod("foo", "bar", "boo");
fooBarMethod(newString[]{"foo", "var", "boo"});
publicvoidmyMethod(String... variables){
for(String variable : variables){
// business logic}
}
78. What will be the output of the below java program and define the steps of Execution of
the java program with the help of the below code?
classInterviewBit{
inti;
staticintj;
{
System.out.println(" Instance Block 1. Value of i = "+i);
}
static{
System.out.println(" Static Block 1. Value of j = "+j);
method_2();
}
{
i = 5;
}
static{
j = 10;
}
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
publicstaticvoidmain(String[] args){
InterviewBit ib = newInterviewBit();
}
publicvoidmethod_1(){
System.out.println(" Instance method. ");
}
static{
System.out.println(" Static Block 2. Value of j = "+j);
}
{
System.out.println(" Instance Block 2. Value of i = "+i);
method_1();
}
publicstaticvoidmethod_2(){
System.out.println(" Static method. ");
}
}
The Output we get by executing this program will be
Static Block 1. Value of j = 0
Static method.
Static Block 2. Value of j = 10
Instance Block 1. Value of i = 0
Instance Block 2. Value of i = 5
Instance method.
Welcome to InterviewBit
This is a java tricky interview question frequently asked in java interviews for the experienced. The output will be like this because, when the
java program is compiled and gets executed, then there are various steps followed for execution. And the steps are -
• Identification of Static Members from top to bottom.
• Execution of Static variable assignment and a Static block from top to bottom.
• Execution of the main method.
• Identification of Instance Members from top to bottom.
• Execution of Instance variable assignment and Instance block from top to bottom.
• Execution of Constructor.
In above steps from 4 to 6, will be executed for every object creation. If we create multiple objects then for every object these steps will be
performed.
Now from the above code, the execution will happen like this -
1. In the step of identification of static members. It is found that -
• static int j.
• static block.
• main method.
 • static method_2.
During identification, the JVM will assign the default value in the static int j variable. Then it is currently in the state of reading and indirectly
writing. Because the original value is not assigned.
2. In the next step, it will execute the static block and assign the value in static variables.
• First static block it will print and because execution from top to bottom and original value in j is not assigned. So it will print the default
value of 0.
• After executing static block 1. It will execute the static method_1 because it is called from the static block 1.
• Then it will assign the original value of 5 in the j variable. And executes the remaining static block.
3. Now it will execute the main method. In which it will create an object for the class InterviewBit. And then the execution of instances will
happen.
4. Identify the instance variables and blocks from top to bottom.
• int i.
• Instance block 1.
• Instance method_1.
Like a static variable, the instance variable also has been initialized with the default value 0 and will be in the state of reading and writing
indirectly.
5. It will execute the instance methods and assign the original value to the instance variable.
• Prints the Instance block 1. And the current value of i is not assigned till now, so it will print 0.
• Assign the original value to i. Then print instance block 2. And after that instance method will be called and printed because it is being
called in the instance block.
6. And at the last step, the constructor will be invoked and the lines will be executed in the constructor.
This is how the java program gets executed.
79. Define System.out.println().
System.out.println() is used to print the message on the console. System - It is a class present in java.lang package. Out is the static variable
of type PrintStream class present in the System class. println() is the method present in the PrintStream class.
So if we justify the statement, then we can say that if we want to print anything on the console then we need to call the println() method
that was present in PrintStream class. And we can call this using the output object that is present in the System class.
80. Can you explain the Java thread lifecycle?
Java thread life cycle is as follows:
• New – When the instance of the thread is created and the start() method has not been invoked, the thread is considered to be alive
and hence in the NEW state.
• Runnable – Once the start() method is invoked, before the run() method is called by JVM, the thread is said to be in RUNNABLE (ready
to run) state. This state can also be entered from the Waiting or Sleeping state of the thread.
• Running – When the run() method has been invoked and the thread starts its execution, the thread is said to be in a RUNNING state.
• Non-Runnable (Blocked/Waiting) – When the thread is not able to run despite the fact of its aliveness, the thread is said to be in a
NON-RUNNABLE state. Ideally, after some time of its aliveness, the thread should go to a runnable state.
○ A thread is said to be in a Blocked state if it wants to enter synchronized code but it is unable to as another thread is operating in
that synchronized block on the same object. The first thread has to wait until the other thread exits the synchronized block.
○ A thread is said to be in a Waiting state if it is waiting for the signal to execute from another thread, i.e it waits for work until the
signal is received.
• Terminated – Once the run() method execution is completed, the thread is said to enter the TERMINATED step and is considered to
not be alive.
The following flowchart clearly explains the lifecycle of the thread in Java.

81. What could be the tradeoff between the usage of an unordered array versus the usage of
an ordered array?
• The main advantage of having an ordered array is the reduced search time complexity of O(log n) whereas the time complexity in an
unordered array is O(n).
• The main drawback of the ordered array is its increased insertion time which is O(n) due to the fact that its element has to reordered
to maintain the order of array during every insertion whereas the time complexity in the unordered array is only O(1).
• Considering the above 2 key points and depending on what kind of scenario a developer requires, the appropriate data structure can
be used for implementation.
82. Is it possible to import the same class or package twice in Java and what happens to it
during runtime?
It is possible to import a class or package more than once, however, it is redundant because the JVM internally loads the package or class
only once.
83. In case a package has sub packages, will it suffice to import only the main package? e.g.
Does importing of com.myMainPackage.* also import com.myMainPackage.mySubPackage.*?
This is a big NO. We need to understand that the importing of the sub-packages of a package needs to be done explicitly. Importing the
parent package only results in the import of the classes within it and not the contents of its child/sub-packages.
84. Will the finally block be executed if the code System.exit(0) is written at the end of try
block?
NO. The control of the program post System.exit(0) is immediately gone and the program gets terminated which is why the finally block
never gets executed.
85. What do you understand by marker interfaces in Java?
Marker interfaces, also known as tagging interfaces are those interfaces that have no methods and constants defined in them. They are
there for helping the compiler and JVM to get run time-related information regarding the objects.
86. Explain the term “Double Brace Initialisation” in Java?
This is a convenient means of initializing any collections in Java. Consider the below example.
importjava.util.HashSet;
importjava.util.Set;

publicclassIBDoubleBraceDemo{
publicstaticvoidmain(String[] args){
Set<String> stringSets = newHashSet<String>()
{
{
add("set1");
add("set2");
add("set3");
}
};

doSomething(stringSets);
}

privatestaticvoiddoSomething(Set<String> stringSets){
System.out.println(stringSets);
}
}
In the above example, we see that the stringSets were initialized by using double braces.
• The first brace does the task of creating an anonymous inner class that has the capability of accessing the parent class’s behavior. In
our example, we are creating the subclass of HashSet so that it can use the add() method of HashSet.
• The second braces do the task of initializing the instances.
Care should be taken while initializing through this method as the method involves the creation of anonymous inner classes which can cause
problems during the garbage collection or serialization processes and may also result in memory leaks.
87. Why is it said that the length() method of String class doesn't return accurate results?
• The length method returns the number of Unicode units of the String. Let's understand what Unicode units are and what is the
confusion below.
• We know that Java uses UTF-16 for String representation. With this Unicode, we need to understand the below two Unicode related
terms:
○ Code Point: This represents an integer denoting a character in the code space.
 ○ Code Unit: This is a bit sequence used for encoding the code points. In order to do this, one or more units might be required for
representing a code point.
• Under the UTF-16 scheme, the code points were divided logically into 17 planes and the first plane was called the Basic Multilingual
Plane (BMP). The BMP has classic characters - U+0000 to U+FFFF. The rest of the characters- U+10000 to U+10FFFF were termed as the
supplementary characters as they were contained in the remaining planes.
○ The code points from the first plane are encoded using one 16-bit code unit
○ The code points from the remaining planes are encoded using two code units.
Now if a string contained supplementary characters, the length function would count that as 2 units and the result of the length() function
would not be as per what is expected.
In other words, if there is 1 supplementary character of 2 units, the length of that SINGLE character is considered to be TWO - Notice the
inaccuracy here? As per the java documentation, it is expected, but as per the real logic, it is inaccurate.
88. What is the output of the below code and why?
publicclassInterviewBit{
publicstaticvoidmain(String[] args){
System.out.println('b'+ 'i'+ 't');
}
}
“bit” would have been the result printed if the letters were used in double-quotes (or the string literals). But the question has the character
literals (single quotes) being used which is why concatenation wouldn't occur. The corresponding ASCII values of each character would be
added and the result of that sum would be printed.
The ASCII values of ‘b’, ‘i’, ‘t’ are:
• ‘b’ = 98
• ‘i’ = 105
• ‘t’ = 116
98 + 105 + 116 = 319
Hence 319 would be printed.
89. What are the possible ways of making object eligible for garbage collection (GC) in Java?
First Approach: Set the object references to null once the object creation purpose is served.
publicclassIBGarbageCollect{
publicstaticvoidmain(String [] args){
String s1 = "Some String";
// s1 referencing String object - not yet eligible for GCs1 = null; // now s1 is eligible for GC}
}
Second Approach: Point the reference variable to another object. Doing this, the object which the reference variable was referencing before
becomes eligible for GC.
publicclassIBGarbageCollect{
publicstaticvoidmain(String [] args){
String s1 = "To Garbage Collect";
String s2 = "Another Object";
System.out.println(s1); // s1 is not yet eligible for GCs1 = s2; // Point s1 to other object pointed by s2/* Here, the string object having the
content "To Garbage Collect" is not referred by any reference variable. Therefore, it is eligible for GC */}
}
Third Approach: Island of Isolation Approach: When 2 reference variables pointing to instances of the same class, and these variables refer
to only each other and the objects pointed by these 2 variables don't have any other references, then it is said to have formed an “Island of
Isolation” and these 2 objects are eligible for GC.
publicclassIBGarbageCollect{
IBGarbageCollect ib;
publicstaticvoidmain(String [] str){
IBGarbageCollect ibgc1 = newIBGarbageCollect();
IBGarbageCollect ibgc2 = newIBGarbageCollect();
ibgc1.ib = ibgc2; //ibgc1 points to ibgc2ibgc2.ib = ibgc1; //ibgc2 points to ibgc1ibgc1 = null;
ibgc2 = null;
/*
* We see that ibgc1 and ibgc2 objects refer
* to only each other and have no valid
* references- these 2 objects for island of isolcation - eligible for GC
*/}
}
90. In the below Java Program, how many objects are eligible for garbage collection?
classMain{
 publicstaticvoidmain(String[] args){
int[][] num = newint[3][];
num[0] = newint[5];
num[1] = newint[2];
num[2] = newint[3];

num[2] = newint[5];
num[0] = newint[4];
num[1] = newint[3];

num = newint[2][];
}
}
In the above program, a total of 7 objects will be eligible for garbage collection. Let’s visually understand what's happening in the code.

In the above figure on line 3, we can see that on each array index we are declaring a new array so the reference will be of that new array on
all the 3 indexes. So the old array will be pointed to by none. So these three are eligible for garbage collection. And on line 4, we are creating
a new array object on the older reference. So that will point to a new array and older multidimensional objects will become eligible for
garbage collection.
91. What is the best way to inject dependency? Also, state the reason.
There is no boundation for using a particular dependency injection. But the recommended approach is -
Setters are mostly recommended for optional dependencies injection, and constructor arguments are recommended for mandatory ones.
This is because constructor injection enables the injection of values into immutable fields and enables reading them more easily.
92. How we can set the spring bean scope. And what supported scopes does it have?
A scope can be set by an annotation such as the @Scope annotation or the "scope" attribute in an XML configuration file. Spring Bean
supports the following five scopes:
• Singleton
• Prototype
• Request
• Session
• Global-session
93. What are the different categories of Java Design patterns?
Java Design patterns are categorized into the following different types. And those are also further categorized as
Structural patterns:
• Adapter
• Bridge
• Filter
• Composite
• Decorator
• Facade
• Flyweight
• Proxy
Behavioral patterns:
• Interpreter
• Template method/ pattern
• Chain of responsibility
• Command pattern
• Iterator pattern
• Strategy pattern
• Visitor pattern
J2EE patterns:
• MVC Pattern
• Data Access Object pattern
• Front controller pattern
• Intercepting filter pattern
• Transfer object pattern
Creational patterns:
• Factory method/Template
• Abstract Factory
• Builder
• Prototype
• Singleton
94. What is a Memory Leak? Discuss some common causes of it.
The Java Garbage Collector (GC) typically removes unused objects when they are no longer required, but when they are still referenced, the
unused objects cannot be removed. So this causes the memory leak problem. Example - Consider a linked list like the structure below -

In the above image, there are unused objects that are not referenced. But then also Garbage collection will not free it. Because it is
referencing some existing referenced object. So this can be the situation of memory leak.
Some common causes of Memory leaks are -
 • When there are Unbounded caches.
• Excessive page swapping is done by the operating system.
• Improper written custom data structures.
• Inserting into a collection object without first deleting it.
etc.
95. Assume a thread has a lock on it, calling the sleep() method on that thread will release the
lock?
A thread that has a lock won't be released even after it calls sleep(). Despite the thread sleeping for a specified period of time, the lock will
not be released.
Java Programming Interview Questions
96. Check if a given string is palindrome using recursion.
/*
* Java program to check if a given inputted string is palindrome or not using recursion.
*/importjava.util.*;
publicclassInterviewBit{
publicstaticvoidmain(String args[]){
Scanner s = newScanner(System.in);
String word = s.nextLine();
System.out.println("Is "+word+" palindrome? - "+isWordPalindrome(word));
}

publicstaticbooleanisWordPalindrome(String word){
String reverseWord = getReverseWord(word);
//if word equals its reverse, then it is a palindromeif(word.equals(reverseWord)){
returntrue;
}
returnfalse;
}

publicstaticString getReverseWord(String word){

if(word == null|| word.isEmpty()){
returnword;
}

returnword.charAt(word.length()- 1) + getReverseWord(word.substring(0, word.length() - 1));

}
}
97. Write a Java Program to print Fibonacci Series using Recursion.
classInterviewBit{
publicstaticvoidprintFibonacci(intval_1, intval_2, intnum){
//Base Caseif(num == 0)
return;
//Printing the next Fibonacci number System.out.print( val_1 + val_2 + " ");
//Recursively calling for printing Fibonacci for remaining lengthprintFibonacci(val_2, val_1+val_2, --num);
}
publicstaticvoidmain(String args[]){
System.out.println(" *** Fibonacci Series *** ");
//Printing the first two valuesSystem.out.print("0 1 ");
//Calling Method to print the fibonacci for length 10printFibonacci(0, 1, 10);
}
}
In the above code, we are printing the base 2 Fibonacci values 0 and 1. And then based on the length of Fibonacci to be printed, we are using
the helper function to print that.
98. Write a Java program to check if the two strings are anagrams.
The main idea is to validate the length of strings and then if found equal, convert the string to char array and then sort the arrays and check
if both are equal.
importjava.util.Arrays;
importjava.util.Scanner;
publicclassInterviewBit{
publicstaticvoidmain(String[] args){
Scanner s = newScanner(System.in);
//Input from two stringsSystem.out.print("First String: ");
String string1 = s.nextLine();
System.out.print("Second String: ");
String string2 = s.nextLine();
// check for the lengthif(string1.length() == string2.length()) {
// convert strings to char arraychar[] characterArray1 = string1.toCharArray();
char[] characterArray2 = string2.toCharArray();
// sort the arraysArrays.sort(characterArray1);
Arrays.sort(characterArray2);
// check for equality, if found equal then anagram, else not an anagrambooleanisAnagram = Arrays.equals(characterArray1,
characterArray2);
System.out.println("Anagram: "+ isAnagram);
}
}
99. Write a Java Program to find the factorial of a given number.
publicclassFindFactorial{
publicstaticvoidmain(String[] args){
intnum = 10;
longfactorialResult = 1l;
for(inti = 1; i <= num; ++i)
{
factorialResult *= i;
}
System.out.println("Factorial: "+factorialResult);
}
}
100. Given an array of non-duplicating numbers from 1 to n where one number is missing,
write an efficient java program to find that missing number.
Idea is to find the sum of n natural numbers using the formula and then finding the sum of numbers in the given array. Subtracting these two
sums results in the number that is the actual missing number. This results in O(n) time complexity and O(1) space complexity.
publicclassIBMissingNumberProblem{
publicstaticvoidmain(String[] args){
int[] array={4,3,8,7,5,2,6};
intmissingNumber = findMissingNum(array);
System.out.println("Missing Number is "+ missingNumber);
}
publicstaticintfindMissingNum(int[] array){
intn=array.length+1;
intsumOfFirstNNums=n*(n+1)/2;
intactualSumOfArr=0;
for(inti = 0; i < array.length; i++) {
actualSumOfArr+=array[i];
}
returnsumOfFirstNNums-actualSumOfArr;
}
}
101. Write a Java Program to check if any number is a magic number or not. A number is said
to be a magic number if after doing sum of digits in each step and inturn doing sum of digits of
that sum, the ultimate result (when there is only one digit left) is 1.
Example, consider the number:
• Step 1: 163 => 1+6+3 = 10
• Step 2: 10 => 1+0 = 1 => Hence 163 is a magic number
publicclassIBMagicNumber{
publicstaticvoidmain(String[] args){
intnum = 163;
intsumOfDigits = 0;
 while(num > 0|| sumOfDigits > 9)
{
if(num == 0)
{
num = sumOfDigits;
sumOfDigits = 0;
}
sumOfDigits += num % 10;
num /= 10;
}
// If sum is 1, original number is magic number if(sumOfDigits == 1) {
System.out.println("Magic number");
}else{
System.out.println("Not magic number");
}
}
}
102. Write a Java program to create and throw custom exceptions.
classInterviewBit{
publicstaticvoidmain(String args[])throwsCustomException {
// Throwing the custom exception be passing the messagethrownewCustomException(" This is my custom Exception ");
}
}
//Creating Custom Exception ClassclassCustomExceptionextendsException{
//Defining Constructor to throw exception messagepublicCustomException(String message){
super(message);
}
}
We have created the exception class named with CustomException and called the base exception constructor with the error message that
we want to print. And to avoid handling exceptions in the main method, we have used the throws keyword in the method declaration.
103. Write a Java program to reverse a string.
classInterviewBit{
publicstaticvoidmain(String[] args){
//Input StringString str = "Welcome to InterviewBit";

//Pointers.inti = 0, j = str.length()-1;

//Result character array to store the reversed string.char[] revString = newchar[j+1];

//Looping and reversing the string.while(i < j){

revString[j] = str.charAt(i);
revString[i] = str.charAt(j);
i++;
j--;
}
//Printing the reversed String.System.out.println("Reversed String = "+ String.valueOf(revString));
}
}
In the above code, we are storing the last character from the string to the first and the first value to the last in the output character array.
And doing the same thing in the loop for the remaining 2nd to n-1 characters. This is how the string will be reversed.
104. Write a Java program to rotate arrays 90 degree clockwise by taking matrices from user
input.
mport java.util.Scanner;
publicclassInterviewBit{
publicstaticvoidmain(String[] args){
Scanner sc = newScanner(System.in);
intno;
System.out.print("Enter size of Array : ");
no = sc.nextInt();
int[][] a = newint[no][no];
 System.out.print("Enter "+ no*no+" Element Array : ");

for(inti = 0; i<no; i++){

for(intj = 0; j<no; j++){
a[i][j] = sc.nextInt();
}
}
System.out.print("\nArray Before Rotation\n\n");
for(inti = 0; i<no; i++){
for(intj = 0; j<no; j++){
System.out.print(a[i][j] + " ");
}
System.out.println();
}

System.out.println("\n");
//Rotation//Transposefor(inti = 0; i < no; i++){
for(intj = i; j < no; j++){
inttemp = a[i][j];
a[i][j] = a[j][i];
a[j][i] = temp;
}
}

//Reverse Each rowfor(inti = 0; i < no; i++){

intl, j;
for(j = 0, l = no -1; j < l; j++){
inttemp = a[i][j];
a[i][j] = a[i][l];
a[i][l] = temp;
l--;
}
}

System.out.println("Array After Rotation - \n");

for(inti = 0; i<no; i++){

for(intj = 0; j<no; j++){
System.out.print(a[i][j] + " ");
}
System.out.println();
}
}
}
In the above code, for rotating the matrix to 90 degrees we are first transposing the matrix so the row becomes the column. And after that,
we are reversing each row in the matrix. So this is how the matrix got rotated.
105. Write a java program to check if any number given as input is the sum of 2 prime
numbers.
Example :
Input - 18
Output -
18 = 13 + 5
18 = 11 + 7
publicclassInterviewBit{
// Method to Check Prime Numberprivatestaticintcheck_prime(intnum){
intflag = 0;
for(inti = 2; i<=num/2; i++){
if(num%i == 0){
flag = 1;
return1;
}
 }
if(flag == 0)
return0;
return1;
}
// Method to get print the prime sumprivatestaticvoidfind(intnum){
for(inti = 2; i <= num/2; i++){
if(check_prime(i) == 0){
if(check_prime(num-i) == 0)
System.out.println(num + " = "+ (num-i) + " "+ i);
}
}
}
publicstaticvoidmain(String[] args){
find(18);
}
}
In the above code, for any number n, we find all the 2 pairs of numbers that are added together resulting in n. And each checking number if
it is prime. If it is prime then we are printing that.
106. Write a Java program for solving the Tower of Hanoi Problem.
publicclassInterviewBit{
//Recursive Method for Solving the Tower of hanoi.privatestaticvoidTOH(charsource, charauxiliary, chardestination, intnumOfDisk){
if(numOfDisk > 0){
TOH(source, destination, auxiliary, numOfDisk-1);
System.out.println("Move 1 disk from "+source+" to "+destination+" using "+auxiliary+".");
TOH(auxiliary, source, destination, numOfDisk-1);
}
}
publicstaticvoidmain(String[] args){
TOH('A','B','C', 3);
}
}
In the above code we are first moving the n-1 disk from Tower A to Tower B, then moving that nth disk from Tower A to Tower C, and finally,
the remaining n-1 disk from Tower B to Tower C. And we are doing this recursively for the n-1 disk.
107. Implement Binary Search in Java using recursion.
publicclassMain{
//Recursive method for binary searchprivatestaticbooleanbinarySearch(int[] arr, intlow, inthigh, intkey){

//Calculating Mid.intmid = (low + high)/2;

//Base Case.if(low > high)

returnfalse;

//Checking if the key is found in the middle.if(arr[mid] == key)

returntrue;

//Searching on the left half if a key exists there. if(key < arr[mid])
returnbinarySearch(arr, low, mid-1, key);

//Searching on the other half otherwise.returnbinarySearch(arr, mid+1, high, key);

}
publicstaticvoidmain(String[] args){

int[] arr = {2, 5, 9, 13, 17, 21, 30};

if(binarySearch(arr, 0, (arr.length-1), 30))
System.out.println(" Element Found. ");
elseSystem.out.println(" Element not Found.");
}
}
In the above code, we are finding the middle element each time and checking if the element is in the middle or not. If it is not, then we check
on which side from the middle it exists. And Recursively searching on the particular subarray. So this way we are reducing the search space
by 2 every time. So the search time is very low.
Conclusion
108. Conclusion
Java is one of the simple high-level languages that provides powerful tools and impressive standards required for application development. It
was also one of the first languages to provide amazing threading support for tackling concurrency-based problems. The easy-to-use syntax
and the built-in features of Java combined with the stability it provides to applications are the main reasons for this language to have ever-
growing usage in the software community.
Join our community and share your java interview experiences.
Recommended Interview Preparation Resources
• How to Become a Java Developer?
• How much does a Java Developer earn in India?
• Java Projects
• Java Programming Questions for interview
• Java 8 Interview Questions
• Java String Interview Questions
• Spring Interview Questions
• Hibernate Interview Questions
• Java Collections Interview Questions
• Array Interview Questions
• Design Patterns Interview Questions
• Multithreading Interview Questions
• Java Tutorial
• Java MCQ
• Advance Java MCQ
• Difference Between C++ and Java
• Difference Between C and Java
• Difference Between Java and Javascript
• Kotlin Vs Java
• Java Vs Python
• Features of Java 9
• Java 8 Features
• Java Frameworks
• Java Developer Skills
• Java IDE
• Java 11 Features
JAVA SE Download
Additional Technical Interview Questions
Java MCQ
1.
What is the component used for compiling, debugging, and executing java programs?
JDK
JVM
JRE
JIT
2.
What component does the task of bytecode to machine code conversion?
JDK
JVM
JRE
JIT
3.
Which of the following is the functionality of the java interpreter?
Interpretor is nothing but the JIT compiler.
It acts as medium between JVM and JIT.
It does the conversion of byte code to machine code.
It reads the high level code and executes them.
4.
When an object has its own lifecycle and its child object cant belong to another parent object, what is it called?
Association
Aggregation
Composition
Encapsulation
5.
What is the output of the below piece of code?
classInterviewBit{
publicvoidmethod1(intnum1,floatnum2){
System.out.println("int-float method");
}
publicvoidmethod1(floatnum1,intnum2){
System.out.println("float-int method");
}
publicstaticvoidmain(String[] args){
InterviewBit interviewBit=newInterviewBit();
interviewBit.method1(40,20);
}
}
int-float method
float-int method
Compilation Error
Run Time error
6.
What is the output of the following code?
classInterviewBit{
intfun(intn){
intresult;
result = fun (n - 1);
returnresult;
}
}
classDriver{
publicstaticvoidmain(String args[]){
InterviewBit ib = newInterviewBit() ;
System.out.print(ib.fun(12));
}
}
0
1
Compilation Error
Run time error
7.
Which of the following happens when the garbage collection process kicks off during the execution of the thread?
Garbage collection does not happen during thread execution.
Thread pauses while the garbage collection process runs.
Both the process takes place simultaneously and does not interfere its execution.
Nothing happens, the thread proceeds with execution.
8.
What is the output of the below code?
classInterviewBit{
publicstaticvoidmain(String args[]){
String obj = "Hello";
String obj1 = "InterviewBit";
String obj2 = "Hello";
System.out.println(obj.equals(obj1) + " "+ obj.equals(obj2));
}
}
false false
true true
true false
false true
9.
What is the functionality of Class.getInstance()?
It invokes the constructor.
It has the same functionality of new operator.
It creates object if the class does not have constructor defined.
None of the above.
10.
What is the output of the below code?
classInterviewBit{
publicintnum1;
staticintnum2;
voidcalculate(inta, intb){
num1 += a ;
num2 += b;
}
}
classDriver{
publicstaticvoidmain(String args[]){
InterviewBit obj1 = newInterviewBit();
InterviewBit obj2 = newInterviewBit();
obj1.num1 = 0;
obj1.num2 = 0;
obj1.calculate(1, 2);
obj2.num1 = 0;
obj2.calculate(2, 3);
System.out.println(obj1.num1 + " "+ obj2.num2);
}
}
12
15
42
25
11.
What is the output of the following code?
classInterviewBit{

intcalculate(inta, intb){
try{
returna-b;
}catch(Exception e){
returna+b;
}finally{
returna*b;
}
}
}
classDriver{
publicstaticvoidmain(String args[]){
InterviewBit obj1 = newInterviewBit();
intresult = obj1.calculate(2, 3);
System.out.println("Result: "+ result);
}
}
5
-1
6
Run time Error

From <https://www.interviewbit.com/java-interview-questions/>
Java Interview Questions from interview javatpoint
Monday, February 13, 2023 11:08 PM

1) What is Java?
Java is the high-level, object-oriented, robust, secure programming language, platform-independent,
high performance, Multithreaded, and portable programming language. It was developed by James
Gosling in June 1991. It can also be known as the platform as it provides its own JRE and API.

2) What are the differences between C++ and Java?

The differences between C++ and Java are given in the following table.
Current Time 0:10
/
Duration 4:57
Â

Comparison C++ Java

Index
Platform- C++ is platform-dependent. Java is platform-independent.
independent
Mainly used C++ is mainly used for system Java is mainly used for application programming. It
for programming. is widely used in window, web-based, enterprise
and mobile applications.
Design Goal C++ was designed for systems and Java was designed and created as an interpreter for
applications programming. It was printing systems but later extended as a support
an extension of C programming network computing. It was designed with a goal of
language. being easy to use and accessible to a broader
audience.
Goto C++ supports the goto statement. Java doesn't support the goto statement.
Multiple C++ supports multiple inheritance. Java doesn't support multiple inheritance through
inheritance class. It can be achieved by interfaces in java.
Operator C++ supports operator Java doesn't support operator overloading.
Overloading overloading.
Pointers C++ supports pointers. You can Java supports pointer internally. However, you can't
write pointer program in C++. write the pointer program in java. It means java has
restricted pointer support in Java.
Compiler C++ uses compiler only. C++ is Java uses compiler and interpreter both. Java source
and compiled and run using the code is converted into bytecode at compilation
Interpreter compiler which converts source time. The interpreter executes this bytecode at
code into machine code so, C++ is runtime and produces output. Java is interpreted
platform dependent. that is why it is platform independent.
Call by Value C++ supports both call by value Java supports call by value only. There is no call by
and Call by and call by reference. reference in java.
reference
Structure C++ supports structures and Java doesn't support structures and unions.
and Union unions.
Thread C++ doesn't have built-in support Java has built-in thread support.
Support for threads. It relies on third-party
libraries for thread support.
Documentati C++ doesn't support Java supports documentation comment (/** ... */)
on comment documentation comment. to create documentation for java source code.
Virtual C++ supports virtual keyword so Java has no virtual keyword. We can override all
Keyword that we can decide whether or not non-static methods by default. In other words, non-
override a function. static methods are virtual by default.
unsigned C++ doesn't support >>> operator. Java supports unsigned right shift >>> operator that
right fills zero at the top for the negative numbers. For
shift >>> positive numbers, it works same like >> operator.
Inheritance C++ creates a new inheritance tree Java uses a single inheritance tree always because
Tree always. all classes are the child of Object class in java. The
object class is the root of the inheritance tree in
java.
Hardware C++ is nearer to hardware. Java is not so interactive with hardware.
Object- C++ is an object-oriented Java is also an object-oriented language. However,
oriented language. However, in C language, everything (except fundamental types) is an object
single root hierarchy is not in Java. It is a single root hierarchy as everything
possible. gets derived from java.lang.Object.

3) List the features of Java Programming language.

There are the following features in Java Programming Language.
• Simple: Java is easy to learn. The syntax of Java is based on C++ which makes easier to write the
program in it.
• Object-Oriented: Java follows the object-oriented paradigm which allows us to maintain our code
as the combination of different type of objects that incorporates both data and behavior.
• Portable: Java supports read-once-write-anywhere approach. We can execute the Java program
on every machine. Java program (.java) is converted to bytecode (.class) which can be easily run
on every machine.
• Platform Independent: Java is a platform independent programming language. It is different from
other programming languages like C and C++ which needs a platform to be executed. Java comes
with its platform on which its code is executed. Java doesn't depend upon the operating system to
be executed.
• Secured: Java is secured because it doesn't use explicit pointers. Java also provides the concept of
ByteCode and Exception handling which makes it more secured.
• Robust: Java is a strong programming language as it uses strong memory management. The
concepts like Automatic garbage collection, Exception handling, etc. make it more robust.
• Architecture Neutral: Java is architectural neutral as it is not dependent on the architecture. In C,
the size of data types may vary according to the architecture (32 bit or 64 bit) which doesn't exist
in Java.
• Interpreted: Java uses the Just-in-time (JIT) interpreter along with the compiler for the program
execution.
• High Performance: Java is faster than other traditional interpreted programming languages
because Java bytecode is "close" to native code. It is still a little bit slower than a compiled
language (e.g., C++).
• Multithreaded: We can write Java programs that deal with many tasks at once by defining
multiple threads. The main advantage of multi-threading is that it doesn't occupy memory for
each thread. It shares a common memory area. Threads are important for multi-media, Web
applications, etc.
• Distributed: Java is distributed because it facilitates users to create distributed applications in
 Java. RMI and EJB are used for creating distributed applications. This feature of Java makes us able
to access files by calling the methods from any machine on the internet.
• Dynamic: Java is a dynamic language. It supports dynamic loading of classes. It means classes are
loaded on demand. It also supports functions from its native languages, i.e., C and C++.

4) What do you understand by Java virtual machine?

Java Virtual Machine is a virtual machine that enables the computer to run the Java program. JVM acts
like a run-time engine which calls the main method present in the Java code. JVM is the specification
which must be implemented in the computer system. The Java code is compiled by JVM to be a
Bytecode which is machine independent and close to the native code.

5) What is the difference between JDK, JRE, and JVM?

JVM
JVM is an acronym for Java Virtual Machine; it is an abstract machine which provides the runtime
environment in which Java bytecode can be executed. It is a specification which specifies the working of
Java Virtual Machine. Its implementation has been provided by Oracle and other companies. Its
implementation is known as JRE.
JVMs are available for many hardware and software platforms (so JVM is platform dependent). It is a
runtime instance which is created when we run the Java class. There are three notions of the JVM:
specification, implementation, and instance.
JRE
JRE stands for Java Runtime Environment. It is the implementation of JVM. The Java Runtime
Environment is a set of software tools which are used for developing Java applications. It is used to
provide the runtime environment. It is the implementation of JVM. It physically exists. It contains a set
of libraries + other files that JVM uses at runtime.
JDK
JDK is an acronym for Java Development Kit. It is a software development environment which is used to
develop Java applications and applets. It physically exists. It contains JRE + development tools. JDK is an
implementation of any one of the below given Java Platforms released by Oracle Corporation:
• Standard Edition Java Platform
• Enterprise Edition Java Platform
• Micro Edition Java Platform
More Details.

6) How many types of memory areas are allocated by JVM?

Many types:
1. Class(Method) Area: Class Area stores per-class structures such as the runtime constant pool,
field, method data, and the code for methods.
2. Heap: It is the runtime data area in which the memory is allocated to the objects
3. Stack: Java Stack stores frames. It holds local variables and partial results, and plays a part in
method invocation and return. Each thread has a private JVM stack, created at the same time as
the thread. A new frame is created each time a method is invoked. A frame is destroyed when its
method invocation completes.
4. Program Counter Register: PC (program counter) register contains the address of the Java virtual
machine instruction currently being executed.
5. Native Method Stack: It contains all the native methods used in the application.
More Details.

7) What is JIT compiler?

Just-In-Time(JIT) compiler: It is used to improve the performance. JIT compiles parts of the bytecode
that have similar functionality at the same time, and hence reduces the amount of time needed for
compilation. Here the term “compiler” refers to a translator from the instruction set of a Java virtual
machine (JVM) to the instruction set of a specific CPU.

8) What is the platform?

A platform is the hardware or software environment in which a piece of software is executed. There are
two types of platforms, software-based and hardware-based. Java provides the software-based
platform.

9) What are the main differences between the Java platform and
other platforms?
There are the following differences between the Java platform and other platforms.
• Java is the software-based platform whereas other platforms may be the hardware platforms or
software-based platforms.
• Java is executed on the top of other hardware platforms whereas other platforms can only have
the hardware components.

10) What gives Java its 'write once and run anywhere' nature?
The bytecode. Java compiler converts the Java programs into the class file (Byte Code) which is the
intermediate language between source code and machine code. This bytecode is not platform specific
and can be executed on any computer.

11) What is classloader?

Classloader is a subsystem of JVM which is used to load class files. Whenever we run the java program, it
is loaded first by the classloader. There are three built-in classloaders in Java.
1. Bootstrap ClassLoader: This is the first classloader which is the superclass of Extension
classloader. It loads the rt.jar file which contains all class files of Java Standard Edition like
java.lang package classes, java.net package classes, java.util package classes, java.io package
classes, java.sql package classes, etc.
2. Extension ClassLoader: This is the child classloader of Bootstrap and parent classloader of System
classloader. It loads the jar files located inside $JAVA_HOME/jre/lib/ext directory.
3. System/Application ClassLoader: This is the child classloader of Extension classloader. It loads the
class files from the classpath. By default, the classpath is set to the current directory. You can
change the classpath using "-cp" or "-classpath" switch. It is also known as Application classloader.

12) Is Empty .java file name a valid source file name?

Yes, Java allows to save our java file by .java only, we need to compile it by javac .java and run by java
classname Let's take a simple example:
1. //save by .java only
2. class A{
3. public static void main(String args[]){
4. System.out.println("Hello java");
5. }
6. }
7. //compile by javac .java
8. //run by java A
compile it by javac .java
run it by java A

13) Is delete, next, main, exit or null keyword in java?

No.

14) If I don't provide any arguments on the command line, then what
will the value stored in the String array passed into the main()
method, empty or NULL?
It is empty, but not null.

15) What if I write static public void instead of public static void?
The program compiles and runs correctly because the order of specifiers doesn't matter in Java.

16) What is the default value of the local variables?

The local variables are not initialized to any default value, neither primitives nor object references.

17) What are the various access specifiers in Java?

In Java, access specifiers are the keywords which are used to define the access scope of the method,
class, or a variable. In Java, there are four access specifiers given below.
• Public The classes, methods, or variables which are defined as public, can be accessed by any class
or method.
• Protected Protected can be accessed by the class of the same package, or by the sub-class of this
class, or within the same class.
• Default Default are accessible within the package only. By default, all the classes, methods, and
variables are of default scope.
• Private The private class, methods, or variables defined as private can be accessed within the class
only.

18) What is the purpose of static methods and variables?

The methods or variables defined as static are shared among all the objects of the class. The static is the
part of the class and not of the object. The static variables are stored in the class area, and we do not
need to create the object to access such variables. Therefore, static is used in the case, where we need
to define variables or methods which are common to all the objects of the class.
For example, In the class simulating the collection of the students in a college, the name of the college is
the common attribute to all the students. Therefore, the college name will be defined as static.

19) What are the advantages of Packages in Java?

There are various advantages of defining packages in Java.
• Packages avoid the name clashes.
• The Package provides easier access control.
• We can also have the hidden classes that are not visible outside and used by the package.
• It is easier to locate the related classes.

20) What is the output of the following Java program?

1. class Test
2. {
3. public static void main (String args[])
4. {
5. System.out.println(10 + 20 + "Javatpoint");
6. System.out.println("Javatpoint" + 10 + 20);
7. }
8. }
The output of the above code will be
30Javatpoint
Javatpoint1020
Explanation
In the first case, 10 and 20 are treated as numbers and added to be 30. Now, their sum 30 is treated as
the string and concatenated with the string Javatpoint. Therefore, the output will be 30Javatpoint.
In the second case, the string Javatpoint is concatenated with 10 to be the string Javatpoint10 which will
then be concatenated with 20 to be Javatpoint1020.

21) What is the output of the following Java program?

1. class Test
2. {
3. public static void main (String args[])
4. {
5. System.out.println(10 * 20 + "Javatpoint");
6. System.out.println("Javatpoint" + 10 * 20);
7. }
8. }
The output of the above code will be
200Javatpoint
Javatpoint200
Explanation
In the first case, The numbers 10 and 20 will be multiplied first and then the result 200 is treated as the
string and concatenated with the string Javatpoint to produce the output 200Javatpoint.
In the second case, The numbers 10 and 20 will be multiplied first to be 200 because the precedence of
the multiplication is higher than addition. The result 200 will be treated as the string and concatenated
with the string Javatpointto produce the output as Javatpoint200.

22) What is the output of the following Java program?

1. class Test
2. {
3. public static void main (String args[])
4. {
5. for(int i=0; 0; i++)
6. {
7. System.out.println("Hello Javatpoint");
8. }
9. }
10. }
The above code will give the compile-time error because the for loop demands a boolean value in the
second part and we are providing an integer value, i.e., 0.

Core Java - OOPs Concepts: Initial OOPs Interview Questions

There is given more than 50 OOPs (Object-Oriented Programming and System) interview questions.
However, they have been categorized in many sections such as constructor interview questions, static
interview questions, Inheritance Interview questions, Abstraction interview question, Polymorphism
interview questions, etc. for better understanding.

23) What is object-oriented paradigm?

It is a programming paradigm based on objects having data and methods defined in the class to which it
belongs. Object-oriented paradigm aims to incorporate the advantages of modularity and reusability.
Objects are the instances of classes which interacts with one another to design applications and
programs. There are the following features of the object-oriented paradigm.
• Follows the bottom-up approach in program design.
• Focus on data with methods to operate upon the object's data
• Includes the concept like Encapsulation and abstraction which hides the complexities from the
user and show only functionality.
• Implements the real-time approach like inheritance, abstraction, etc.
• The examples of the object-oriented paradigm are C++, Simula, Smalltalk, Python, C#, etc.

24) What is an object?

The Object is the real-time entity having some state and behavior. In Java, Object is an instance of the
class having the instance variables as the state of the object and the methods as the behavior of the
object. The object of a class can be created by using the new keyword.

25) What is the difference between an object-oriented programming

language and object-based programming language?
There are the following basic differences between the object-oriented language and object-based
language.
• Object-oriented languages follow all the concepts of OOPs whereas, the object-based language
doesn't follow all the concepts of OOPs like inheritance and polymorphism.
• Object-oriented languages do not have the inbuilt objects whereas Object-based languages have
the inbuilt objects, for example, JavaScript has window object.
• Examples of object-oriented programming are Java, C#, Smalltalk, etc. whereas the examples of
object-based languages are JavaScript, VBScript, etc.

26) What will be the initial value of an object reference which is

defined as an instance variable?
All object references are initialized to null in Java.

Core Java - OOPs Concepts: Constructor Interview Questions

27) What is the constructor?
The constructor can be defined as the special type of method that is used to initialize the state of an
object. It is invoked when the class is instantiated, and the memory is allocated for the object. Every
time, an object is created using the new keyword, the default constructor of the class is called. The
name of the constructor must be similar to the class name. The constructor must not have an explicit
return type.
More Details.

28) How many types of constructors are used in Java?

Based on the parameters passed in the constructors, there are two types of constructors in Java.
• Default Constructor: default constructor is the one which does not accept any value. The default
constructor is mainly used to initialize the instance variable with the default values. It can also be
used for performing some useful task on object creation. A default constructor is invoked
implicitly by the compiler if there is no constructor defined in the class.
• Parameterized Constructor: The parameterized constructor is the one which can initialize the
instance variables with the given values. In other words, we can say that the constructors which
can accept the arguments are called parameterized constructors.
29) What is the purpose of a default constructor?
The purpose of the default constructor is to assign the default value to the objects. The java compiler
creates a default constructor implicitly if there is no constructor in the class.
1. class Student3{
2. int id;
3. String name;
4.
5. void display(){System.out.println(id+" "+name);}
6.
7. public static void main(String args[]){
8. Student3 s1=new Student3();
9. Student3 s2=new Student3();
10. s1.display();
11. s2.display();
12. }
13. }
Test it Now
Output:
0 null
0 null
Explanation: In the above class, you are not creating any constructor, so compiler provides you a default
constructor. Here 0 and null values are provided by default constructor.

More Details.
30) Does constructor return any value?
Ans: yes, The constructor implicitly returns the current instance of the class (You can't use an explicit
return type with the constructor). More Details.

31)Is constructor inherited?

No, The constructor is not inherited.

32) Can you make a constructor final?

No, the constructor can't be final.

33) Can we overload the constructors?

Yes, the constructors can be overloaded by changing the number of arguments accepted by the
constructor or by changing the data type of the parameters. Consider the following example.
1. class Test
2. {
3. int i;
4. public Test(int k)
5. {
6. i=k;
7. }
8. public Test(int k, int m)
9. {
10. System.out.println("Hi I am assigning the value max(k, m) to i");
11. if(k>m)
12. {
13. i=k;
14. }
15. else
16. {
17. i=m;
18. }
19. }
20. }
21. public class Main
22. {
23. public static void main (String args[])
24. {
25. Test test1 = new Test(10);
26. Test test2 = new Test(12, 15);
27. System.out.println(test1.i);
28. System.out.println(test2.i);
29. }
30. }
31.
In the above program, The constructor Test is overloaded with another constructor. In the first call to
the constructor, The constructor with one argument is called, and i will be initialized with the value 10.
However, In the second call to the constructor, The constructor with the 2 arguments is called, and i will
be initialized with the value 15.

34) What do you understand by copy constructor in Java?

There is no copy constructor in java. However, we can copy the values from one object to another like
copy constructor in C++.
There are many ways to copy the values of one object into another in java. They are:
• By constructor
• By assigning the values of one object into another
• By clone() method of Object class
In this example, we are going to copy the values of one object into another using java constructor.
1. //Java program to initialize the values from one object to another
2. class Student6{
3. int id;
4. String name;
5. //constructor to initialize integer and string
6. Student6(int i,String n){
7. id = i;
8. name = n;
9. }
10. //constructor to initialize another object
11. Student6(Student6 s){
12. id = s.id;
13. name =s.name;
14. }
15. void display(){System.out.println(id+" "+name);}
16.
17. public static void main(String args[]){
18. Student6 s1 = new Student6(111,"Karan");
19. Student6 s2 = new Student6(s1);
20. s1.display();
21. s2.display();
22. }
23. }
Test it Now
Output:
111 Karan
111 Karan

35) What are the differences between the constructors and methods?
There are many differences between constructors and methods. They are given below.
Java Constructor Java Method
A constructor is used to initialize the state of an object. A method is used to expose the
behavior of an object.
A constructor must not have a return type. A method must have a return type.
The constructor is invoked implicitly. The method is invoked explicitly.
The Java compiler provides a default constructor if you don't The method is not provided by the
have any constructor in a class. compiler in any case.
The constructor name must be same as the class name. The method name may or may not be
same as class name.
36) What is the output of the following Java program?
1. public class Test
2. {
3. Test(int a, int b)
4. {
5. System.out.println("a = "+a+" b = "+b);
6. }
7. Test(int a, float b)
8. {
9. System.out.println("a = "+a+" b = "+b);
10. }
11. public static void main (String args[])
12. {
13. byte a = 10;
14. byte b = 15;
15. Test test = new Test(a,b);
16. }
17. }
The output of the following program is:
a = 10 b = 15
Here, the data type of the variables a and b, i.e., byte gets promoted to int, and the first parameterized
constructor with the two integer parameters is called.

37) What is the output of the following Java program?

1. class Test
2. {
3. int i;
4. }
5. public class Main
6. {
7. public static void main (String args[])
 8. {
9. Test test = new Test();
10. System.out.println(test.i);
11. }
12. }
The output of the program is 0 because the variable i is initialized to 0 internally. As we know that a
default constructor is invoked implicitly if there is no constructor in the class, the variable i is initialized
to 0 since there is no constructor in the class.

38) What is the output of the following Java program?

1. class Test
2. {
3. int test_a, test_b;
4. Test(int a, int b)
5. {
6. test_a = a;
7. test_b = b;
8. }
9. public static void main (String args[])
10. {
11. Test test = new Test();
12. System.out.println(test.test_a+" "+test.test_b);
13. }
14. }
There is a compiler error in the program because there is a call to the default constructor in the main
method which is not present in the class. However, there is only one parameterized constructor in the
class Test. Therefore, no default constructor is invoked by the constructor implicitly.

Core Java - OOPs Concepts: static keyword Interview

Questions
39) What is the static variable?
The static variable is used to refer to the common property of all objects (that is not unique for each
object), e.g., The company name of employees, college name of students, etc. Static variable gets
memory only once in the class area at the time of class loading. Using a static variable makes your
program more memory efficient (it saves memory). Static variable belongs to the class rather than the
object.
1. //Program of static variable
2.
3. class Student8{
4. int rollno;
5. String name;
6. static String college ="ITS";
7.
8. Student8(int r,String n){
9. rollno = r;
10. name = n;
11. }
12. void display (){System.out.println(rollno+" "+name+" "+college);}
13.
14. public static void main(String args[]){
 15. Student8 s1 = new Student8(111,"Karan");
16. Student8 s2 = new Student8(222,"Aryan");
17.
18. s1.display();
19. s2.display();
20. }
21. }
Test it Now
Output:111 Karan ITS
222 Aryan ITS

More Details.

40) What is the static method?

• A static method belongs to the class rather than the object.
• There is no need to create the object to call the static methods.
• A static method can access and change the value of the static variable.
More Details.

41) What are the restrictions that are applied to the Java static
methods?
Two main restrictions are applied to the static methods.
• The static method can not use non-static data member or call the non-static method directly.
• this and super cannot be used in static context as they are non-static.

42) Why is the main method static?

Because the object is not required to call the static method. If we make the main method non-static,
JVM will have to create its object first and then call main() method which will lead to the extra memory
allocation. More Details.

43) Can we override the static methods?

No, we can't override static methods.
44) What is the static block?
Static block is used to initialize the static data member. It is executed before the main method, at the
time of classloading.
1. class A2{
2. static{System.out.println("static block is invoked");}
3. public static void main(String args[]){
4. System.out.println("Hello main");
5. }
6. }
Test it Now
Output: static block is invoked
Hello main
More Details.

45) Can we execute a program without main() method?

Ans) No, It was possible before JDK 1.7 using the static block. Since JDK 1.7, it is not possible. More
Details.

46) What if the static modifier is removed from the signature of the
main method?
Program compiles. However, at runtime, It throws an error "NoSuchMethodError."

47) What is the difference between static (class) method and instance
method?
static or class method instance method
1)A method that is declared as static is known as the static A method that is not declared as
method. static is known as the instance
method.
2)We don't need to create the objects to call the static methods. The object is required to call the
instance methods.
3)Non-static (instance) members cannot be accessed in the Static and non-static variables both
static context (static method, static block, and static nested can be accessed in instance methods.
class) directly.
4)For example: public static int cube(int n){ return n*n*n;} For example: public void msg(){...}.

48) Can we make constructors static?

As we know that the static context (method, block, or variable) belongs to the class, not the object.
Since Constructors are invoked only when the object is created, there is no sense to make the
constructors static. However, if you try to do so, the compiler will show the compiler error.

49) Can we make the abstract methods static in Java?

In Java, if we make the abstract methods static, It will become the part of the class, and we can directly
call it which is unnecessary. Calling an undefined method is completely useless therefore it is not
allowed.

50) Can we declare the static variables and methods in an abstract

class?
Yes, we can declare static variables and methods in an abstract method. As we know that there is no
requirement to make the object to access the static context, therefore, we can access the static context
declared inside the abstract class by using the name of the abstract class. Consider the following
example.
1. abstract class Test
2. {
3. static int i = 102;
4. static void TestMethod()
5. {
6. System.out.println("hi !! I am good !!");
7. }
8. }
9. public class TestClass extends Test
10. {
11. public static void main (String args[])
12. {
13. Test.TestMethod();
14. System.out.println("i = "+Test.i);
15. }
16. }
Output
hi !! I am good !!
i = 102

Core Java - OOPs Concepts: Inheritance Interview Questions

51) What is this keyword in java?
The this keyword is a reference variable that refers to the current object. There are the various uses of
this keyword in Java. It can be used to refer to current class properties such as instance methods,
variable, constructors, etc. It can also be passed as an argument into the methods or constructors. It can
also be returned from the method as the current class instance.

More Details.

52) What are the main uses of this keyword?

There are the following uses of this keyword.
• this can be used to refer to the current class instance variable.
• this can be used to invoke current class method (implicitly)
• this() can be used to invoke the current class constructor.
• this can be passed as an argument in the method call.
• this can be passed as an argument in the constructor call.
• this can be used to return the current class instance from the method.
53) Can we assign the reference to this variable?
No, this cannot be assigned to any value because it always points to the current class object and this is
the final reference in Java. However, if we try to do so, the compiler error will be shown. Consider the
following example.
1. public class Test
2. {
3. public Test()
4. {
5. this = null;
6. System.out.println("Test class constructor called");
7. }
8. public static void main (String args[])
9. {
10. Test t = new Test();
11. }
12. }
Output
Test.java:5: error: cannot assign a value to final variable this
this = null;
^
1 error

54) Can this keyword be used to refer static members?

Yes, It is possible to use this keyword to refer static members because this is just a reference variable
which refers to the current class object. However, as we know that, it is unnecessary to access static
variables through objects, therefore, it is not the best practice to use this to refer static members.
Consider the following example.
1. public class Test
2. {
3. static int i = 10;
4. public Test ()
5. {
6. System.out.println(this.i);
7. }
8. public static void main (String args[])
9. {
10. Test t = new Test();
11. }
12. }
Output
10

55) How can constructor chaining be done using this keyword?

Constructor chaining enables us to call one constructor from another constructor of the class with
respect to the current class object. We can use this keyword to perform constructor chaining within the
same class. Consider the following example which illustrates how can we use this keyword to achieve
constructor chaining.
1. public class Employee
2. {
3. int id,age;
4. String name, address;
 5. public Employee (int age)
6. {
7. this.age = age;
8. }
9. public Employee(int id, int age)
10. {
11. this(age);
12. this.id = id;
13. }
14. public Employee(int id, int age, String name, String address)
15. {
16. this(id, age);
17. this.name = name;
18. this.address = address;
19. }
20. public static void main (String args[])
21. {
22. Employee emp = new Employee(105, 22, "Vikas", "Delhi");
23. System.out.println("ID: "+emp.id+" Name:"+emp.name+" age:"+emp.age+" address: "+emp.a
ddress);
24. }
25.
26. }
Output
ID: 105 Name:Vikas age:22 address: Delhi

56) What are the advantages of passing this into a method instead of
the current class object itself?
As we know, that this refers to the current class object, therefore, it must be similar to the current class
object. However, there can be two main advantages of passing this into a method instead of the current
class object.
• this is a final variable. Therefore, this cannot be assigned to any new value whereas the current
class object might not be final and can be changed.
• this can be used in the synchronized block.

57) What is the Inheritance?

Inheritance is a mechanism by which one object acquires all the properties and behavior of another
object of another class. It is used for Code Reusability and Method Overriding. The idea behind
inheritance in Java is that you can create new classes that are built upon existing classes. When you
inherit from an existing class, you can reuse methods and fields of the parent class. Moreover, you can
add new methods and fields in your current class also. Inheritance represents the IS-A relationship
which is also known as a parent-child relationship.
There are five types of inheritance in Java.
• Single-level inheritance
• Multi-level inheritance
• Multiple Inheritance
• Hierarchical Inheritance
• Hybrid Inheritance
Multiple inheritance is not supported in Java through class.
More Details.
58) Why is Inheritance used in Java?
There are various advantages of using inheritance in Java that is given below.
• Inheritance provides code reusability. The derived class does not need to redefine the method of
base class unless it needs to provide the specific implementation of the method.
• Runtime polymorphism cannot be achieved without using inheritance.
• We can simulate the inheritance of classes with the real-time objects which makes OOPs more
realistic.
• Inheritance provides data hiding. The base class can hide some data from the derived class by
making it private.
• Method overriding cannot be achieved without inheritance. By method overriding, we can give a
specific implementation of some basic method contained by the base class.

59) Which class is the superclass for all the classes?

The object class is the superclass of all other classes in Java.

60) Why is multiple inheritance not supported in java?

To reduce the complexity and simplify the language, multiple inheritance is not supported in java.
Consider a scenario where A, B, and C are three classes. The C class inherits A and B classes. If A and B
classes have the same method and you call it from child class object, there will be ambiguity to call the
method of A or B class.
Since the compile-time errors are better than runtime errors, Java renders compile-time error if you
inherit 2 classes. So whether you have the same method or different, there will be a compile time error.
1. class A{
2. void msg(){System.out.println("Hello");}
3. }
4. class B{
5. void msg(){System.out.println("Welcome");}
6. }
7. class C extends A,B{//suppose if it were
8.
9. Public Static void main(String args[]){
10. C obj=new C();
11. obj.msg();//Now which msg() method would be invoked?
12. }
13. }
Test it Now
Compile Time Error

61) What is aggregation?

Aggregation can be defined as the relationship between two classes where the aggregate class contains
a reference to the class it owns. Aggregation is best described as a has-a relationship. For example, The
aggregate class Employee having various fields such as age, name, and salary also contains an object of
Address class having various fields such as Address-Line 1, City, State, and pin-code. In other words, we
can say that Employee (class) has an object of Address class. Consider the following example.
Address.java
1. public class Address {
2. String city,state,country;
3.
4. public Address(String city, String state, String country) {
5. this.city = city;
6. this.state = state;
 7. this.country = country;
8. }
9.
10. }
Employee.java
1. public class Emp {
2. int id;
3. String name;
4. Address address;
5.
6. public Emp(int id, String name,Address address) {
7. this.id = id;
8. this.name = name;
9. this.address=address;
10. }
11.
12. void display(){
13. System.out.println(id+" "+name);
14. System.out.println(address.city+" "+address.state+" "+address.country);
15. }
16.
17. public static void main(String[] args) {
18. Address address1=new Address("gzb","UP","india");
19. Address address2=new Address("gno","UP","india");
20.
21. Emp e=new Emp(111,"varun",address1);
22. Emp e2=new Emp(112,"arun",address2);
23.
24. e.display();
25. e2.display();
26.
27. }
28. }
Output
111 varun
gzb UP india
112 arun
gno UP india

62) What is composition?

Holding the reference of a class within some other class is known as composition. When an object
contains the other object, if the contained object cannot exist without the existence of container object,
then it is called composition. In other words, we can say that composition is the particular case of
aggregation which represents a stronger relationship between two objects. Example: A class contains
students. A student cannot exist without a class. There exists composition between class and students.

63) What is the difference between aggregation and composition?

Aggregation represents the weak relationship whereas composition represents the strong relationship.
For example, the bike has an indicator (aggregation), but the bike has an engine (composition).

64) Why does Java not support pointers?

The pointer is a variable that refers to the memory address. They are not used in Java because they are
unsafe(unsecured) and complex to understand.

65) What is super in java?

The super keyword in Java is a reference variable that is used to refer to the immediate parent class
object. Whenever you create the instance of the subclass, an instance of the parent class is created
implicitly which is referred by super reference variable. The super() is called in the class constructor
implicitly by the compiler if there is no super or this.
1. class Animal{
2. Animal(){System.out.println("animal is created");}
3. }
4. class Dog extends Animal{
5. Dog(){
6. System.out.println("dog is created");
7. }
8. }
9. class TestSuper4{
10. public static void main(String args[]){
11. Dog d=new Dog();
12. }
13. }
Test it Now
Output:
animal is created
dog is created
More Details.

66) How can constructor chaining be done by using the super

keyword?
1. class Person
2. {
3. String name,address;
4. int age;
5. public Person(int age, String name, String address)
6. {
7. this.age = age;
8. this.name = name;
9. this.address = address;
10. }
11. }
12. class Employee extends Person
13. {
14. float salary;
15. public Employee(int age, String name, String address, float salary)
16. {
17. super(age,name,address);
18. this.salary = salary;
19. }
20. }
21. public class Test
22. {
23. public static void main (String args[])
24. {
 25. Employee e = new Employee(22, "Mukesh", "Delhi", 90000);
26. System.out.println("Name: "+e.name+" Salary: "+e.salary+" Age: "+e.age+" Address: "+e.addr
ess);
27. }
28. }
Output
Name: Mukesh Salary: 90000.0 Age: 22 Address: Delhi

67) What are the main uses of the super keyword?

There are the following uses of super keyword.
• super can be used to refer to the immediate parent class instance variable.
• super can be used to invoke the immediate parent class method.
• super() can be used to invoke immediate parent class constructor.

68) What are the differences between this and super keyword?
There are the following differences between this and super keyword.
• The super keyword always points to the parent class contexts whereas this keyword always points
to the current class context.
• The super keyword is primarily used for initializing the base class variables within the derived class
constructor whereas this keyword primarily used to differentiate between local and instance
variables when passed in the class constructor.
• The super and this must be the first statement inside constructor otherwise the compiler will
throw an error.

69) What is the output of the following Java program?

1. class Person
2. {
3. public Person()
4. {
5. System.out.println("Person class constructor called");
6. }
7. }
8. public class Employee extends Person
9. {
10. public Employee()
11. {
12. System.out.println("Employee class constructor called");
13. }
14. public static void main (String args[])
15. {
16. Employee e = new Employee();
17. }
18. }
Output
Person class constructor called
Employee class constructor called
Explanation
The super() is implicitly invoked by the compiler if no super() or this() is included explicitly within the
derived class constructor. Therefore, in this case, The Person class constructor is called first and then the
Employee class constructor is called.
70) Can you use this() and super() both in a constructor?
No, because this() and super() must be the first statement in the class constructor.
Example:
1. public class Test{
2. Test()
3. {
4. super();
5. this();
6. System.out.println("Test class object is created");
7. }
8. public static void main(String []args){
9. Test t = new Test();
10. }
11. }
Output:
Test.java:5: error: call to this must be first statement in constructor

71)What is object cloning?

The object cloning is used to create the exact copy of an object. The clone() method of the Object class is
used to clone an object. The java.lang.Cloneable interface must be implemented by the class whose
object clone we want to create. If we don't implement Cloneable interface, clone() method generates
CloneNotSupportedException.
1. protected Object clone() throws CloneNotSupportedException
2.
More Details.

Core Java - OOPs Concepts: Method Overloading Interview

Questions
72) What is method overloading?
Method overloading is the polymorphism technique which allows us to create multiple methods with
the same name but different signature. We can achieve method overloading in two ways.
• By Changing the number of arguments
• By Changing the data type of arguments
Method overloading increases the readability of the program. Method overloading is performed to
figure out the program quickly.
More Details.

73) Why is method overloading not possible by changing the return

type in java?
In Java, method overloading is not possible by changing the return type of the program due to avoid the
ambiguity.
1. class Adder{
2. static int add(int a,int b){return a+b;}
3. static double add(int a,int b){return a+b;}
4. }
5. class TestOverloading3{
6. public static void main(String[] args){
7. System.out.println(Adder.add(11,11));//ambiguity
8. }}
Test it Now
Output:
Compile Time Error: method add(int, int) is already defined in class Adder
More Details.

74) Can we overload the methods by making them static?

No, We cannot overload the methods by just applying the static keyword to them(number of
parameters and types are the same). Consider the following example.
1. public class Animal
2. {
3. void consume(int a)
4. {
5. System.out.println(a+" consumed!!");
6. }
7. static void consume(int a)
8. {
9. System.out.println("consumed static "+a);
10. }
11. public static void main (String args[])
12. {
13. Animal a = new Animal();
14. a.consume(10);
15. Animal.consume(20);
16. }
17. }
Output
Animal.java:7: error: method consume(int) is already defined in class Animal
static void consume(int a)
^
Animal.java:15: error: non-static method consume(int) cannot be referenced from a static context
Animal.consume(20);
^
2 errors

75) Can we overload the main() method?

Yes, we can have any number of main methods in a Java program by using method overloading.
More Details.

76) What is method overloading with type promotion?

By Type promotion is method overloading, we mean that one data type can be promoted to another
implicitly if no exact matching is found.
As displayed in the above diagram, the byte can be promoted to short, int, long, float or double. The
short datatype can be promoted to int, long, float or double. The char datatype can be promoted to int,
long, float or double and so on. Consider the following example.
1. class OverloadingCalculation1{
2. void sum(int a,long b){System.out.println(a+b);}
3. void sum(int a,int b,int c){System.out.println(a+b+c);}
4.
5. public static void main(String args[]){
6. OverloadingCalculation1 obj=new OverloadingCalculation1();
7. obj.sum(20,20);//now second int literal will be promoted to long
8. obj.sum(20,20,20);
9. }
10. }
Test it Now
Output
40
60

77) What is the output of the following Java program?

1. class OverloadingCalculation3{
2. void sum(int a,long b){System.out.println("a method invoked");}
3. void sum(long a,int b){System.out.println("b method invoked");}
4.
5. public static void main(String args[]){
6. OverloadingCalculation3 obj=new OverloadingCalculation3();
7. obj.sum(20,20);//now ambiguity
8. }
9. }
Output
OverloadingCalculation3.java:7: error: reference to sum is ambiguous
obj.sum(20,20);//now ambiguity
^
both method sum(int,long) in OverloadingCalculation3
 and method sum(long,int) in OverloadingCalculation3 match
1 error
Explanation
There are two methods defined with the same name, i.e., sum. The first method accepts the integer and
long type whereas the second method accepts long and the integer type. The parameter passed that are
a = 20, b = 20. We can not tell that which method will be called as there is no clear differentiation
mentioned between integer literal and long literal. This is the case of ambiguity. Therefore, the compiler
will throw an error.

Core Java - OOPs Concepts: Method Overriding Interview

Questions
78) What is method overriding:
If a subclass provides a specific implementation of a method that is already provided by its parent class,
it is known as Method Overriding. It is used for runtime polymorphism and to implement the interface
methods.
Rules for Method overriding
• The method must have the same name as in the parent class.
• The method must have the same signature as in the parent class.
• Two classes must have an IS-A relationship between them.
More Details.

79) Can we override the static method?

No, you can't override the static method because they are the part of the class, not the object.

80) Why can we not override static method?

It is because the static method is the part of the class, and it is bound with class whereas instance
method is bound with the object, and static gets memory in class area, and instance gets memory in a
heap.

81) Can we override the overloaded method?

Yes.

82) Difference between method Overloading and Overriding.

Method Overloading Method Overriding
1) Method overloading increases the Method overriding provides the specific implementation of the
readability of the program. method that is already provided by its superclass.
2) Method overloading occurs within Method overriding occurs in two classes that have IS-A
the class. relationship between them.
3) In this case, the parameters must In this case, the parameters must be the same.
be different.

83) Can we override the private methods?

No, we cannot override the private methods because the scope of private methods is limited to the class
and we cannot access them outside of the class.

84) Can we change the scope of the overridden method in the

subclass?
Yes, we can change the scope of the overridden method in the subclass. However, we must notice that
we cannot decrease the accessibility of the method. The following point must be taken care of while
changing the accessibility of the method.
• The private can be changed to protected, public, or default.
• The protected can be changed to public or default.
• The default can be changed to public.
• The public will always remain public.

85) Can we modify the throws clause of the superclass method while
overriding it in the subclass?
Yes, we can modify the throws clause of the superclass method while overriding it in the subclass.
However, there are some rules which are to be followed while overriding in case of exception handling.
• If the superclass method does not declare an exception, subclass overridden method cannot
declare the checked exception, but it can declare the unchecked exception.
• If the superclass method declares an exception, subclass overridden method can declare same,
subclass exception or no exception but cannot declare parent exception.

86) What is the output of the following Java program?

1. class Base
2. {
3. void method(int a)
4. {
5. System.out.println("Base class method called with integer a = "+a);
6. }
7.
8. void method(double d)
9. {
10. System.out.println("Base class method called with double d ="+d);
11. }
12. }
13.
14. class Derived extends Base
15. {
16. @Override
17. void method(double d)
18. {
19. System.out.println("Derived class method called with double d ="+d);
20. }
21. }
22.
23. public class Main
24. {
25. public static void main(String[] args)
26. {
27. new Derived().method(10);
28. }
29. }
Output
Base class method called with integer a = 10
Explanation
The method() is overloaded in class Base whereas it is derived in class Derived with the double type as
the parameter. In the method call, the integer is passed.
87) Can you have virtual functions in Java?
Yes, all functions in Java are virtual by default.

88) What is covariant return type?

Now, since java5, it is possible to override any method by changing the return type if the return type of
the subclass overriding method is subclass type. It is known as covariant return type. The covariant
return type specifies that the return type may vary in the same direction as the subclass.
1. class A{
2. A get(){return this;}
3. }
4.
5. class B1 extends A{
6. B1 get(){return this;}
7. void message(){System.out.println("welcome to covariant return type");}
8.
9. public static void main(String args[]){
10. new B1().get().message();
11. }
12. }
Test it Now
Output: welcome to covariant return type
More Details.

89) What is the output of the following Java program?

1. class Base
2. {
3. public void baseMethod()
4. {
5. System.out.println("BaseMethod called ...");
6. }
7. }
8. class Derived extends Base
9. {
10. public void baseMethod()
11. {
12. System.out.println("Derived method called ...");
13. }
14. }
15. public class Test
16. {
17. public static void main (String args[])
18. {
19. Base b = new Derived();
20. b.baseMethod();
21. }
22. }

Output
Derived method called ...
Explanation
The method of Base class, i.e., baseMethod() is overridden in Derived class. In Test class, the reference
variable b (of type Base class) refers to the instance of the Derived class. Here, Runtime polymorphism is
achieved between class Base and Derived. At compile time, the presence of method baseMethod
checked in Base class, If it presence then the program compiled otherwise the compiler error will be
shown. In this case, baseMethod is present in Base class; therefore, it is compiled successfully. However,
at runtime, It checks whether the baseMethod has been overridden by Derived class, if so then the
Derived class method is called otherwise Base class method is called. In this case, the Derived class
overrides the baseMethod; therefore, the Derived class method is called.

Core Java - OOPs Concepts: final keyword Interview Questions

90) What is the final variable?
In Java, the final variable is used to restrict the user from updating it. If we initialize the final variable, we
can't change its value. In other words, we can say that the final variable once assigned to a value, can
never be changed after that. The final variable which is not assigned to any value can only be assigned
through the class constructor.

1. class Bike9{
2. final int speedlimit=90;//final variable
3. void run(){
4. speedlimit=400;
5. }
6. public static void main(String args[]){
7. Bike9 obj=new Bike9();
8. obj.run();
9. }
10. }//end of class
Test it Now
Output:Compile Time Error
More Details.

91) What is the final method?

If we change any method to a final method, we can't override it. More Details.
1. class Bike{
2. final void run(){System.out.println("running");}
3. }
4.
 5. class Honda extends Bike{
6. void run(){System.out.println("running safely with 100kmph");}
7.
8. public static void main(String args[]){
9. Honda honda= new Honda();
10. honda.run();
11. }
12. }
Test it Now
Output:Compile Time Error

92) What is the final class?

If we make any class final, we can't inherit it into any of the subclasses.
1. final class Bike{}
2.
3. class Honda1 extends Bike{
4. void run(){System.out.println("running safely with 100kmph");}
5.
6. public static void main(String args[]){
7. Honda1 honda= new Honda1();
8. honda.run();
9. }
10. }
Test it Now
Output:Compile Time Error
More Details.

93) What is the final blank variable?

A final variable, not initialized at the time of declaration, is known as the final blank variable. We can't
initialize the final blank variable directly. Instead, we have to initialize it by using the class constructor. It
is useful in the case when the user has some data which must not be changed by others, for example,
PAN Number. Consider the following example:
1. class Student{
2. int id;
3. String name;
4. final String PAN_CARD_NUMBER;
5. ...
6. }
More Details.

94) Can we initialize the final blank variable?

Yes, if it is not static, we can initialize it in the constructor. If it is static blank final variable, it can be
initialized only in the static block. More Details.

95) Can you declare the main method as final?

Yes, We can declare the main method as public static final void main(String[] args){}.

96) What is the output of the following Java program?

1. class Main {
2. public static void main(String args[]){
3. final int i;
 4. i = 20;
5. System.out.println(i);
6. }
7. }
Output
20
Explanation
Since i is the blank final variable. It can be initialized only once. We have initialized it to 20. Therefore, 20
will be printed.

97) What is the output of the following Java program?

1. class Base
2. {
3. protected final void getInfo()
4. {
5. System.out.println("method of Base class");
6. }
7. }
8.
9. public class Derived extends Base
10. {
11. protected final void getInfo()
12. {
13. System.out.println("method of Derived class");
14. }
15. public static void main(String[] args)
16. {
17. Base obj = new Base();
18. obj.getInfo();
19. }
20. }
Output
Derived.java:11: error: getInfo() in Derived cannot override getInfo() in Base
protected final void getInfo()
^
overridden method is final
1 error
Explanation
The getDetails() method is final; therefore it can not be overridden in the subclass.

98) Can we declare a constructor as final?

The constructor can never be declared as final because it is never inherited. Constructors are not
ordinary methods; therefore, there is no sense to declare constructors as final. However, if you try to do
so, The compiler will throw an error.

99) Can we declare an interface as final?

No, we cannot declare an interface as final because the interface must be implemented by some class to
provide its definition. Therefore, there is no sense to make an interface final. However, if you try to do
so, the compiler will show an error.

100) What is the difference between the final method and abstract
method?
The main difference between the final method and abstract method is that the abstract method cannot
be final as we need to override them in the subclass to give its definition.

From <https://www.javatpoint.com/corejava-interview-questions>
101) What is the difference between compile-time polymorphism and
runtime polymorphism?
There are the following differences between compile-time polymorphism and runtime polymorphism.
SN compile-time polymorphism Runtime polymorphism
1 In compile-time polymorphism, call In runtime polymorphism, call to an overridden method
to a method is resolved at compile- is resolved at runtime.
time.
2 It is also known as static binding, It is also known as dynamic binding, late binding,
early binding, or overloading. overriding, or dynamic method dispatch.
3 Overloading is a way to achieve Overriding is a way to achieve runtime polymorphism in
compile-time polymorphism in which, we can redefine some particular method or
which, we can define multiple variable in the derived class. By using overriding, we can
methods or constructors with give some specific implementation to the base class
different signatures. properties in the derived class.
4 It provides fast execution because It provides slower execution as compare to compile-time
the type of an object is determined because the type of an object is determined at run-time.
at compile-time.
5 Compile-time polymorphism Run-time polymorphism provides more flexibility
provides less flexibility because all because all the things are resolved at runtime.
the things are resolved at compile-
time.

102) What is Runtime Polymorphism?

Runtime polymorphism or dynamic method dispatch is a process in which a call to an overridden
method is resolved at runtime rather than at compile-time. In this process, an overridden method is
called through the reference variable of a superclass. The determination of the method to be called is
based on the object being referred to by the reference variable.
1. class Bike{
2. void run(){System.out.println("running");}
3. }
4. class Splendor extends Bike{
5. void run(){System.out.println("running safely with 60km");}
6. public static void main(String args[]){
7. Bike b = new Splendor();//upcasting
8. b.run();
9. }
10. }
Test it Now
Output:
running safely with 60km.
In this process, an overridden method is called through the reference variable of a superclass. The
determination of the method to be called is based on the object being referred to by the reference
variable.
More details.

103) Can you achieve Runtime Polymorphism by data members?

No, because method overriding is used to achieve runtime polymorphism and data members cannot be
overridden. We can override the member functions but not the data members. Consider the example
given below.
1. class Bike{
2. int speedlimit=90;
3. }
4. class Honda3 extends Bike{
5. int speedlimit=150;
6. public static void main(String args[]){
7. Bike obj=new Honda3();
8. System.out.println(obj.speedlimit);//90
9. }
Test it Now
Output:
90
More details.

104) What is the difference between static binding and dynamic

binding?
In case of the static binding, the type of the object is determined at compile-time whereas, in the
dynamic binding, the type of the object is determined at runtime.
Static Binding
1. class Dog{
2. private void eat(){System.out.println("dog is eating...");}
3.
4. public static void main(String args[]){
5. Dog d1=new Dog();
6. d1.eat();
7. }
8. }
Dynamic Binding
1. class Animal{
2. void eat(){System.out.println("animal is eating...");}
3. }
4.
5. class Dog extends Animal{
6. void eat(){System.out.println("dog is eating...");}
7.
8. public static void main(String args[]){
9. Animal a=new Dog();
10. a.eat();
11. }
12. }
More details.
105) What is the output of the following Java program?
1. class BaseTest
2. {
3. void print()
4. {
5. System.out.println("BaseTest:print() called");
6. }
7. }
8. public class Test extends BaseTest
9. {
10. void print()
11. {
12. System.out.println("Test:print() called");
13. }
14. public static void main (String args[])
15. {
16. BaseTest b = new Test();
17. b.print();
18. }
19. }
Output
Test:print() called
Explanation
It is an example of Dynamic method dispatch. The type of reference variable b is determined at runtime.
At compile-time, it is checked whether that method is present in the Base class. In this case, it is
overridden in the child class, therefore, at runtime the derived class method is called.

106) What is Java instanceOf operator?

The instanceof in Java is also known as type comparison operator because it compares the instance with
type. It returns either true or false. If we apply the instanceof operator with any variable that has a null
value, it returns false. Consider the following example.
1. class Simple1{
2. public static void main(String args[]){
3. Simple1 s=new Simple1();
4. System.out.println(s instanceof Simple1);//true
5. }
6. }
Test it Now
Output
true

An object of subclass type is also a type of parent class. For example, if Dog extends Animal then object
of Dog can be referred by either Dog or Animal class.

Core Java - OOPs Concepts: Abstraction Interview Questions

107) What is the abstraction?
Abstraction is a process of hiding the implementation details and showing only functionality to the user.
It displays just the essential things to the user and hides the internal information, for example, sending
SMS where you type the text and send the message. You don't know the internal processing about the
message delivery. Abstraction enables you to focus on what the object does instead of how it does it.
Abstraction lets you focus on what the object does instead of how it does it.
In Java, there are two ways to achieve the abstraction.
• Abstract Class
• Interface
More details.

108) What is the difference between abstraction and encapsulation?

Abstraction hides the implementation details whereas encapsulation wraps code and data into a single
unit.
More details.

109) What is the abstract class?

A class that is declared as abstract is known as an abstract class. It needs to be extended and its method
implemented. It cannot be instantiated. It can have abstract methods, non-abstract methods,
constructors, and static methods. It can also have the final methods which will force the subclass not to
change the body of the method. Consider the following example.
1. abstract class Bike{
2. abstract void run();
3. }
4. class Honda4 extends Bike{
5. void run(){System.out.println("running safely");}
6. public static void main(String args[]){
7. Bike obj = new Honda4();
8. obj.run();
9. }
10. }
Test it Now
Output
running safely
More details.

110) Can there be an abstract method without an abstract class?

No, if there is an abstract method in a class, that class must be abstract.

111) Is the following program written correctly? If yes then what will
be the output of the program?
1. abstract class Calculate
2. {
3. abstract int multiply(int a, int b);
4. }
5.
6. public class Main
7. {
8. public static void main(String[] args)
9. {
10. int result = new Calculate()
11. {
12. @Override
13. int multiply(int a, int b)
14. {
15. return a*b;
 16. }
17. }.multiply(12,32);
18. System.out.println("result = "+result);
19. }
20. }
Yes, the program is written correctly. The Main class provides the definition of abstract method multiply
declared in abstract class Calculation. The output of the program will be:
Output
384

112) Can you use abstract and final both with a method?
No, because we need to override the abstract method to provide its implementation, whereas we can't
override the final method.

113) Is it possible to instantiate the abstract class?

No, the abstract class can never be instantiated even if it contains a constructor and all of its methods
are implemented.

114) What is the interface?

The interface is a blueprint for a class that has static constants and abstract methods. It can be used to
achieve full abstraction and multiple inheritance. It is a mechanism to achieve abstraction. There can be
only abstract methods in the Java interface, not method body. It is used to achieve abstraction and
multiple inheritance in Java. In other words, you can say that interfaces can have abstract methods and
variables. Java Interface also represents the IS-A relationship. It cannot be instantiated just like the
abstract class. However, we need to implement it to define its methods. Since Java 8, we can have the
default, static, and private methods in an interface.
More details.

115) Can you declare an interface method static?

No, because methods of an interface are abstract by default, and we can not use static and abstract
together.

116) Can the Interface be final?

No, because an interface needs to be implemented by the other class and if it is final, it can't be
implemented by any class.

117) What is a marker interface?

A Marker interface can be defined as the interface which has no data member and member functions.
For example, Serializable, Cloneable are marker interfaces. The marker interface can be declared as
follows.
1. public interface Serializable{
2. }

118) What are the differences between abstract class and interface?
Abstract class Interface
An abstract class can have a method body (non-abstract The interface has only abstract methods.
methods).
An abstract class can have instance variables. An interface cannot have instance variables.
An abstract class can have the constructor. The interface cannot have the constructor.
An abstract class can have static methods. The interface cannot have static methods.
You can extend one abstract class. You can implement multiple interfaces.
The abstract class can provide the implementation of The Interface can't provide the
the interface. implementation of the abstract class.
The abstract keyword is used to declare an abstract The interface keyword is used to declare an
class. interface.
An abstract class can extend another Java class and An interface can extend another Java
implement multiple Java interfaces. interface only.
An abstract class can be extended using keyword An interface class can be implemented using
extends keyword implements
A Java abstract class can have class members like Members of a Java interface are public by
private, protected, etc. default.
Example: Example:
public abstract class Shape{ public interface Drawable{
public abstract void draw(); void draw();
} }

119) Can we define private and protected modifiers for the members
in interfaces?
No, they are implicitly public.

120) When can an object reference be cast to an interface reference?

An object reference can be cast to an interface reference when the object implements the referenced
interface.

121) How to make a read-only class in Java?

A class can be made read-only by making all of the fields private. The read-only class will have only
getter methods which return the private property of the class to the main method. We cannot modify
this property because there is no setter method available in the class. Consider the following example.
1. //A Java class which has only getter methods.
2. public class Student{
3. //private data member
4. private String college="AKG";
5. //getter method for college
6. public String getCollege(){
7. return college;
8. }
9. }

122) How to make a write-only class in Java?

A class can be made write-only by making all of the fields private. The write-only class will have only
setter methods which set the value passed from the main method to the private fields. We cannot read
the properties of the class because there is no getter method in this class. Consider the following
example.
1. //A Java class which has only setter methods.
2. public class Student{
3. //private data member
4. private String college;
 5. //getter method for college
6. public void setCollege(String college){
7. this.college=college;
8. }
9. }

123) What are the advantages of Encapsulation in Java?

There are the following advantages of Encapsulation in Java?
• By providing only the setter or getter method, you can make the class read-only or write-only. In
other words, you can skip the getter or setter methods.
• It provides you the control over the data. Suppose you want to set the value of id which should be
greater than 100 only, you can write the logic inside the setter method. You can write the logic not
to store the negative numbers in the setter methods.
• It is a way to achieve data hiding in Java because other class will not be able to access the data
through the private data members.
• The encapsulate class is easy to test. So, it is better for unit testing.
• The standard IDE's are providing the facility to generate the getters and setters. So, it is easy and
fast to create an encapsulated class in Java.

Core Java - OOPs Concepts: Package Interview Questions

124) What is the package?
A package is a group of similar type of classes, interfaces, and sub-packages. It provides access
protection and removes naming collision. The packages in Java can be categorized into two forms,
inbuilt package, and user-defined package. There are many built-in packages such as Java, lang, awt,
javax, swing, net, io, util, sql, etc. Consider the following example to create a package in Java.
1. //save as Simple.java
2. package mypack;
3. public class Simple{
4. public static void main(String args[]){
5. System.out.println("Welcome to package");
6. }
7. }

More details.
125) What are the advantages of defining packages in Java?
By defining packages, we can avoid the name conflicts between the same class names defined in
different packages. Packages also enable the developer to organize the similar classes more effectively.
For example, one can clearly understand that the classes present in java.io package are used to perform
io related operations.

126) How to create packages in Java?

If you are using the programming IDEs like Eclipse, NetBeans, MyEclipse, etc. click on file->new->project
and eclipse will ask you to enter the name of the package. It will create the project package containing
various directories such as src, etc. If you are using an editor like notepad for java programming, use the
following steps to create the package.
• Define a package package_name. Create the class with the name class_name and save this file
with your_class_name.java.
• Now compile the file by running the following command on the terminal.
1. javac -d . your_class_name.java
The above command creates the package with the name package_name in the present working
directory.
• Now, run the class file by using the absolute class file name, like following.
1. java package_name.class_name

127) How can we access some class in another class in Java?

There are two ways to access a class in another class.
• By using the fully qualified name: To access a class in a different package, either we must use the
fully qualified name of that class, or we must import the package containing that class.
• By using the relative path, We can use the path of the class that is related to the package that
contains our class. It can be the same or subpackage.

128) Do I need to import java.lang package any time? Why?

No. It is by default loaded internally by the JVM.

129) Can I import same package/class twice? Will the JVM load the
package twice at runtime?
One can import the same package or the same class multiple times. Neither compiler nor JVM complains
about it. However, the JVM will internally load the class only once no matter how many times you
import the same class.

130) What is the static import?

By static import, we can access the static members of a class directly, and there is no to qualify it with
the class name.
More details.

Java: Exception Handling Interview Questions

There is given a list of exception handling interview questions with answers. If you know any exception
handling interview question, kindly post it in the comment section.

131) How many types of exception can occur in a Java program?

There are mainly two types of exceptions: checked and unchecked. Here, an error is considered as the
unchecked exception. According to Oracle, there are three types of exceptions:
• Checked Exception: Checked exceptions are the one which are checked at compile-time. For
 example, SQLException, ClassNotFoundException, etc.
• Unchecked Exception: Unchecked exceptions are the one which are handled at runtime because
they can not be checked at compile-time. For example, ArithmaticException,
NullPointerException, ArrayIndexOutOfBoundsException, etc.
• Error: Error cause the program to exit since they are not recoverable. For Example,
OutOfMemoryError, AssertionError, etc.

132) What is Exception Handling?

Exception Handling is a mechanism that is used to handle runtime errors. It is used primarily to handle
checked exceptions. Exception handling maintains the normal flow of the program. There are mainly
two types of exceptions: checked and unchecked. Here, the error is considered as the unchecked
exception.
More details.

133) Explain the hierarchy of Java Exception classes?

The java.lang.Throwable class is the root class of Java Exception hierarchy which is inherited by two
subclasses: Exception and Error. A hierarchy of Java Exception classes are given below:
134) What is the difference between Checked Exception and
Unchecked Exception?
1) Checked Exception
The classes that extend Throwable class except RuntimeException and Error are known as checked
exceptions, e.g., IOException, SQLException, etc. Checked exceptions are checked at compile-time.
2) Unchecked Exception
The classes that extend RuntimeException are known as unchecked exceptions, e.g.,
ArithmeticException, NullPointerException, etc. Unchecked exceptions are not checked at compile-time.
More details.

135) What is the base class for Error and Exception?

The Throwable class is the base class for Error and Exception.

136) Is it necessary that each try block must be followed by a catch

block?
It is not necessary that each try block must be followed by a catch block. It should be followed by either
a catch block OR a finally block. So whatever exceptions are likely to be thrown should be declared in
the throws clause of the method. Consider the following example.
1. public class Main{
2. public static void main(String []args){
3. try{
4. int a = 1;
5. System.out.println(a/0);
6. }
7. finally
8. {
9. System.out.println("rest of the code...");
10. }
11. }
12. }
13.
Output:
Exception in thread main java.lang.ArithmeticException:/ by zero
rest of the code...

137) What is the output of the following Java program?

1. public class ExceptionHandlingExample {
2. public static void main(String args[])
3. {
4. try
5. {
6. int a = 1/0;
7. System.out.println("a = "+a);
8. }
9. catch(Exception e){System.out.println(e);}
10. catch(ArithmeticException ex){System.out.println(ex);}
11. }
12. }
Output
ExceptionHandlingExample.java:10: error: exception ArithmeticException has already been caught
 catch(ArithmeticException ex){System.out.println(ex);}
^
1 error
Explanation
ArithmaticException is the subclass of Exception. Therefore, it can not be used after Exception. Since
Exception is the base class for all the exceptions, therefore, it must be used at last to handle the
exception. No class can be used after this.

138) What is finally block?

The "finally" block is used to execute the important code of the program. It is executed whether an
exception is handled or not. In other words, we can say that finally block is the block which is always
executed. Finally block follows try or catch block. If you don't handle the exception, before terminating
the program, JVM runs finally block, (if any). The finally block is mainly used to place the cleanup code
such as closing a file or closing a connection. Here, we must know that for each try block there can be
zero or more catch blocks, but only one finally block. The finally block will not be executed if program
exits(either by calling System.exit() or by causing a fatal error that causes the process to abort).

More details.

139) Can finally block be used without a catch?

Yes, According to the definition of finally block, it must be followed by a try or catch block, therefore, we
can use try block instead of catch. More details.
140) Is there any case when finally will not be executed?
Finally block will not be executed if program exits(either by calling System.exit() or by causing a fatal
error that causes the process to abort).More details.

141) What is the difference between throw and throws?

throw keyword throws keyword
1) The throw keyword is used to throw an The throws keyword is used to declare an exception.
exception explicitly.
2) The checked exceptions cannot be The checked exception can be propagated with throws
propagated with throw only.
3) The throw keyword is followed by an The throws keyword is followed by class.
instance.
4) The throw keyword is used within the The throws keyword is used with the method signature.
method.
5) You cannot throw multiple exceptions. You can declare multiple exceptions, e.g., public void
method()throws IOException, SQLException.
More details.

142) What is the output of the following Java program?

1. public class Main{
2. public static void main(String []args){
3. try
4. {
5. throw 90;
6. }
7. catch(int e){
8. System.out.println("Caught the exception "+e);
9. }
10.
11. }
12. }
Output
Main.java:6: error: incompatible types: int cannot be converted to Throwable
throw 90;
^
Main.java:8: error: unexpected type
catch(int e){
^
required: class
found: int
2 errors
Explanation
In Java, the throwable objects can only be thrown. If we try to throw an integer object, The compiler will
show an error since we can not throw basic data type from a block of code.

143) What is the output of the following Java program?

1. class Calculation extends Exception
2. {
 3. public Calculation()
4. {
5. System.out.println("Calculation class is instantiated");
6. }
7. public void add(int a, int b)
8. {
9. System.out.println("The sum is "+(a+b));
10. }
11. }
12. public class Main{
13. public static void main(String []args){
14. try
15. {
16. throw new Calculation();
17. }
18. catch(Calculation c){
19. c.add(10,20);
20. }
21. }
22. }
Output
Calculation class is instantiated
The sum is 30
Explanation
The object of Calculation is thrown from the try block which is caught in the catch block. The add() of
Calculation class is called with the integer values 10 and 20 by using the object of this class. Therefore
there sum 30 is printed. The object of the Main class can only be thrown in the case when the type of
the object is throwable. To do so, we need to extend the throwable class.

144) Can an exception be rethrown?

Yes.

145) Can subclass overriding method declare an exception if parent

class method doesn't throw an exception?
Yes but only unchecked exception not checked.
More details.

146) What is exception propagation?

An exception is first thrown from the top of the stack and if it is not caught, it drops down the call stack
to the previous method, If not caught there, the exception again drops down to the previous method,
and so on until they are caught or until they reach the very bottom of the call stack. This procedure is
called exception propagation. By default, checked exceptions are not propagated.
1. class TestExceptionPropagation1{
2. void m(){
3. int data=50/0;
4. }
5. void n(){
6. m();
7. }
8. void p(){
9. try{
 10. n();
11. }catch(Exception e){System.out.println("exception handled");}
12. }
13. public static void main(String args[]){
14. TestExceptionPropagation1 obj=new TestExceptionPropagation1();
15. obj.p();
16. System.out.println("normal flow...");
17. }
18. }
Test it Now
Output:
exception handled
normal flow...

More details.

147) What is the output of the following Java program?

1. public class Main
2. {
3. void a()
4. {
5. try{
6. System.out.println("a(): Main called");
7. b();
8. }catch(Exception e)
9. {
10. System.out.println("Exception is caught");
11. }
12. }
13. void b() throws Exception
14. {
15. try{
16. System.out.println("b(): Main called");
17. c();
18. }catch(Exception e){
19. throw new Exception();
20. }
 21. finally
22. {
23. System.out.println("finally block is called");
24. }
25. }
26. void c() throws Exception
27. {
28. throw new Exception();
29. }
30.
31. public static void main (String args[])
32. {
33. Main m = new Main();
34. m.a();
35. }
36. }
Output
a(): Main called
b(): Main called
finally block is called
Exception is caught
Explanation
In the main method, a() of Main is called which prints a message and call b(). The method b() prints
some message and then call c(). The method c() throws an exception which is handled by the catch block
of method b. However, It propagates this exception by using throw Exception() to be handled by the
method a(). As we know, finally block is always executed therefore the finally block in the method b() is
executed first and prints a message. At last, the exception is handled by the catch block of the method
a().

148) What is the output of the following Java program?

1. public class Calculation
2. {
3. int a;
4. public Calculation(int a)
5. {
6. this.a = a;
7. }
8. public int add()
9. {
10. a = a+10;
11. try
12. {
13. a = a+10;
14. try
15. {
16. a = a*10;
17. throw new Exception();
18. }catch(Exception e){
19. a = a - 10;
20. }
21. }catch(Exception e)
22. {
23. a = a - 10;
 24. }
25. return a;
26. }
27.
28. public static void main (String args[])
29. {
30. Calculation c = new Calculation(10);
31. int result = c.add();
32. System.out.println("result = "+result);
33. }
34. }
Output
result = 290
Explanation
The instance variable a of class Calculation is initialized to 10 using the class constructor which is called
while instantiating the class. The add method is called which returns an integer value result. In add()
method, a is incremented by 10 to be 20. Then, in the first try block, 10 is again incremented by 10 to be
30. In the second try block, a is multiplied by 10 to be 300. The second try block throws the exception
which is caught by the catch block associated with this try block. The catch block again alters the value
of a by decrementing it by 10 to make it 290. Thus the add() method returns 290 which is assigned to
result. However, the catch block associated with the outermost try block will never be executed since
there is no exception which can be handled by this catch block.

Java: String Handling Interview Questions

There is given a list of string handling interview questions with short and pointed answers. If you know
any string handling interview question, kindly post it in the comment section.

149) What is String Pool?

String pool is the space reserved in the heap memory that can be used to store the strings. The main
advantage of using the String pool is whenever we create a string literal; the JVM checks the "string
constant pool" first. If the string already exists in the pool, a reference to the pooled instance is
returned. If the string doesn't exist in the pool, a new string instance is created and placed in the pool.
Therefore, it saves the memory by avoiding the duplicacy.
150) What is the meaning of immutable regarding String?
The simple meaning of immutable is unmodifiable or unchangeable. In Java, String is immutable, i.e.,
once string object has been created, its value can't be changed. Consider the following example for
better understanding.
1. class Testimmutablestring{
2. public static void main(String args[]){
3. String s="Sachin";
4. s.concat(" Tendulkar");//concat() method appends the string at the end
5. System.out.println(s);//will print Sachin because strings are immutable objects
6. }
7. }
Test it Now
Output:
Sachin
More details.

151) Why are the objects immutable in java?

Because Java uses the concept of the string literal. Suppose there are five reference variables, all refer to
one object "sachin". If one reference variable changes the value of the object, it will be affected by all
the reference variables. That is why string objects are immutable in java.
More details.

152) How many ways can we create the string object?

1) String Literal
Java String literal is created by using double quotes. For Example:
1. String s="welcome";
Each time you create a string literal, the JVM checks the "string constant pool" first. If the string already
exists in the pool, a reference to the pooled instance is returned. If the string doesn't exist in the pool, a
new string instance is created and placed in the pool. String objects are stored in a special memory area
known as the string constant pool For example:
1. String s1="Welcome";
2. String s2="Welcome";//It doesn't create a new instance
2) By new keyword
1. String s=new String("Welcome");//creates two objects and one reference variable
In such case, JVM will create a new string object in normal (non-pool) heap memory, and the literal
"Welcome" will be placed in the constant string pool. The variable s will refer to the object in a heap
(non-pool).

153) How many objects will be created in the following code?

1. String s1="Welcome";
2. String s2="Welcome";
3. String s3="Welcome";
Only one object will be created using the above code because strings in Java are immutable.
More details.

154) Why java uses the concept of the string literal?

To make Java more memory efficient (because no new objects are created if it exists already in the
string constant pool).
More details.
155) How many objects will be created in the following code?
1. String s = new String("Welcome");
Two objects, one in string constant pool and other in non-pool(heap).
More details.

156) What is the output of the following Java program?

1. public class Test
2.
3. public static void main (String args[])
4. {
5. String a = new String("Sharma is a good player");
6. String b = "Sharma is a good player";
7. if(a == b)
8. {
9. System.out.println("a == b");
10. }
11. if(a.equals(b))
12. {
13. System.out.println("a equals b");
14. }
15. }
Output
a equals b
Explanation
The operator == also check whether the references of the two string objects are equal or not. Although
both of the strings contain the same content, their references are not equal because both are created by
different ways(Constructor and String literal) therefore, a == b is unequal. On the other hand, the equal()
method always check for the content. Since their content is equal hence, a equals b is printed.

157) What is the output of the following Java program?

1. public class Test
2. {
3. public static void main (String args[])
4. {
5. String s1 = "Sharma is a good player";
6. String s2 = new String("Sharma is a good player");
7. s2 = s2.intern();
8. System.out.println(s1 ==s2);
9. }
10. }
Output
true
Explanation
The intern method returns the String object reference from the string pool. In this case, s1 is created by
using string literal whereas, s2 is created by using the String pool. However, s2 is changed to the
reference of s1, and the operator == returns true.

158) What are the differences between String and StringBuffer?

The differences between the String and StringBuffer is given in the table below.
No. String StringBuffer
1) The String class is immutable. The StringBuffer class is mutable.
2) The String is slow and consumes more memory when The StringBuffer is fast and
you concat too many strings because every time it consumes less memory when you
creates a new instance. cancat strings.
3) The String class overrides the equals() method of Object The StringBuffer class doesn't
class. So you can compare the contents of two strings by override the equals() method of
equals() method. Object class.

159) What are the differences between StringBuffer and

StringBuilder?
The differences between the StringBuffer and StringBuilder is given below.
No. StringBuffer StringBuilder
1) StringBuffer is synchronized, i.e., thread safe. StringBuilder is non-synchronized,i.e., not
It means two threads can't call the methods thread safe. It means two threads can call the
of StringBuffer simultaneously. methods of StringBuilder simultaneously.
2) StringBuffer is less efficient than StringBuilder is more efficient than
StringBuilder. StringBuffer.

160) How can we create an immutable class in Java?

We can create an immutable class by defining a final class having all of its members as final. Consider
the following example.
1. public final class Employee{
2. final String pancardNumber;
3.
4. public Employee(String pancardNumber){
5. this.pancardNumber=pancardNumber;
6. }
7.
8. public String getPancardNumber(){
9. return pancardNumber;
10. }
11.
12. }
More details.

161) What is the purpose of toString() method in Java?

The toString() method returns the string representation of an object. If you print any object, java
compiler internally invokes the toString() method on the object. So overriding the toString() method,
returns the desired output, it can be the state of an object, etc. depending upon your implementation.
By overriding the toString() method of the Object class, we can return the values of the object, so we
don't need to write much code. Consider the following example.
1. class Student{
2. int rollno;
3. String name;
4. String city;
5.
6. Student(int rollno, String name, String city){
7. this.rollno=rollno;
8. this.name=name;
 9. this.city=city;
10. }
11.
12. public String toString(){//overriding the toString() method
13. return rollno+" "+name+" "+city;
14. }
15. public static void main(String args[]){
16. Student s1=new Student(101,"Raj","lucknow");
17. Student s2=new Student(102,"Vijay","ghaziabad");
18.
19. System.out.println(s1);//compiler writes here s1.toString()
20. System.out.println(s2);//compiler writes here s2.toString()
21. }
22. }
Output:
101 Raj lucknow
102 Vijay ghaziabad
More details.

162) Why CharArray() is preferred over String to store the password?

String stays in the string pool until the garbage is collected. If we store the password into a string, it
stays in the memory for a longer period, and anyone having the memory-dump can extract the
password as clear text. On the other hand, Using CharArray allows us to set it to blank whenever we are
done with the password. It avoids the security threat with the string by enabling us to control the
memory.

163) Write a Java program to count the number of words present in a

string?
Program:
1. public class Test
2. {
3. public static void main (String args[])
4. {
5. String s = "Sharma is a good player and he is so punctual";
6. String words[] = s.split(" ");
7. System.out.println("The Number of words present in the string are : "+words.length);
8. }
9. }
Output
The Number of words present in the string are : 10

164) Name some classes present in java.util.regex package.

There are the following classes and interfaces present in java.util.regex package.
• MatchResult Interface
• Matcher class
• Pattern class
• PatternSyntaxException class
165) How the metacharacters are different from the ordinary
characters?
Metacharacters have the special meaning to the regular expression engine. The metacharacters are ^,
$, ., *, +, etc. The regular expression engine does not consider them as the regular characters. To enable
the regular expression engine treating the metacharacters as ordinary characters, we need to escape
the metacharacters with the backslash.

166) Write a regular expression to validate a password. A password

must start with an alphabet and followed by alphanumeric characters;
Its length must be in between 8 to 20.
The regular expression for the above criteria will be: ^[a-zA-Z][a-zA-Z0-9]{8,19} where ^ represents the
start of the regex, [a-zA-Z] represents that the first character must be an alphabet, [a-zA-Z0-9]
represents the alphanumeric character, {8,19} represents that the length of the password must be in
between 8 and 20.

167) What is the output of the following Java program?

1. import java.util.regex.*;
2. class RegexExample2{
3. public static void main(String args[]){
4. System.out.println(Pattern.matches(".s", "as")); //line 4
5. System.out.println(Pattern.matches(".s", "mk")); //line 5
6. System.out.println(Pattern.matches(".s", "mst")); //line 6
7. System.out.println(Pattern.matches(".s", "amms")); //line 7
8. System.out.println(Pattern.matches("..s", "mas")); //line 8
9. }}
Output
true
false
false
false
true
Explanation
line 4 prints true since the second character of string is s, line 5 prints false since the second character is
not s, line 6 prints false since there are more than 3 characters in the string, line 7 prints false since
there are more than 2 characters in the string, and it contains more than 2 characters as well, line 8
prints true since the third character of the string is s.

Core Java: Nested classes and Interfaces Interview Questions

168) What are the advantages of Java inner classes?
There are two types of advantages of Java inner classes.
• Nested classes represent a special type of relationship that is it can access all the members (data
members and methods) of the outer class including private.
• Nested classes are used to develop a more readable and maintainable code because it logically
groups classes and interfaces in one place only.
• Code Optimization: It requires less code to write.

169) What is a nested class?

The nested class can be defined as the class which is defined inside another class or interface. We use
the nested class to logically group classes and interfaces in one place so that it can be more readable
and maintainable. A nested class can access all the data members of the outer class including private
data members and methods. The syntax of the nested class is defined below.
1. class Java_Outer_class{
2. //code
3. class Java_Nested_class{
4. //code
5. }
6. }
7.
There are two types of nested classes, static nested class, and non-static nested class. The non-static
nested class can also be called as inner-class
More details.

170) What are the disadvantages of using inner classes?

There are the following main disadvantages of using inner classes.
• Inner classes increase the total number of classes used by the developer and therefore increases
the workload of JVM since it has to perform some routine operations for those extra classes which
result in slower performance.
• IDEs provide less support to the inner classes as compare to the top level classes and therefore it
annoys the developers while working with inner classes.

171) What are the types of inner classes (non-static nested class) used
in Java?
There are mainly three types of inner classes used in Java.
Type Description
Member Inner A class created within class and outside method.
Class
Anonymous Inner A class created for implementing an interface or extending class. Its name is
Class decided by the java compiler.
Local Inner Class A class created within the method.

172) Is there any difference between nested classes and inner classes?
Yes, inner classes are non-static nested classes. In other words, we can say that inner classes are the
part of nested classes.
More details.

173) Can we access the non-final local variable, inside the local inner
class?
No, the local variable must be constant if you want to access it in the local inner class.
More details.

174) How many class files are created on compiling the OuterClass in
the following program?
1. public class Person {
2. String name, age, address;
3. class Employee{
4. float salary=10000;
5. }
6. class BusinessMen{
7. final String gstin="£4433drt3$";
8. }
9. public static void main (String args[])
10. {
11. Person p = new Person();
12. }
13. }
3 class-files will be created named as Person.class, Person$BusinessMen.class, and Person
$Employee.class.

175) What are anonymous inner classes?

Anonymous inner classes are the classes that are automatically declared and instantiated within an
expression. We cannot apply different access modifiers to them. Anonymous class cannot be static, and
cannot define any static fields, method, or class. In other words, we can say that it a class without the
name and can have only one object that is created by its definition. Consider the following example.
1. abstract class Person{
2. abstract void eat();
3. }
4. class TestAnonymousInner{
5. public static void main(String args[]){
6. Person p=new Person(){
7. void eat(){System.out.println("nice fruits");}
8. };
9. p.eat();
10. }
11. }
Test it Now
Output:
nice fruits
Consider the following example for the working of the anonymous class using interface.
1. interface Eatable{
2. void eat();
3. }
4. class TestAnnonymousInner1{
5. public static void main(String args[]){
6. Eatable e=new Eatable(){
7. public void eat(){System.out.println("nice fruits");}
8. };
9. e.eat();
10. }
11. }
Test it Now
Output:
nice fruits

176) What is the nested interface?

An Interface that is declared inside the interface or class is known as the nested interface. It is static by
default. The nested interfaces are used to group related interfaces so that they can be easy to maintain.
The external interface or class must refer to the nested interface. It can't be accessed directly. The
nested interface must be public if it is declared inside the interface but it can have any access modifier if
declared within the class. The syntax of the nested interface is given as follows.
1. interface interface_name{
2. ...
3. interface nested_interface_name{
4. ...
5. }
6. }
7.
More details.

177) Can a class have an interface?

Yes, an interface can be defined within the class. It is called a nested interface.
More details.

178) Can an Interface have a class?

Yes, they are static implicitly.
More details.
Garbage Collection Interview Questions
179) What is Garbage Collection?
Garbage collection is a process of reclaiming the unused runtime objects. It is performed for memory
management. In other words, we can say that It is the process of removing unused objects from the
memory to free up space and make this space available for Java Virtual Machine. Due to garbage
collection java gives 0 as output to a variable whose value is not set, i.e., the variable has been defined
but not initialized. For this purpose, we were using free() function in the C language and delete() in C++.
In Java, it is performed automatically. So, java provides better memory management.
More details.

180) What is gc()?

The gc() method is used to invoke the garbage collector for cleanup processing. This method is found in
System and Runtime classes. This function explicitly makes the Java Virtual Machine free up the space
occupied by the unused objects so that it can be utilized or reused. Consider the following example for
the better understanding of how the gc() method invoke the garbage collector.
1. public class TestGarbage1{
2. public void finalize(){System.out.println("object is garbage collected");}
3. public static void main(String args[]){
4. TestGarbage1 s1=new TestGarbage1();
5. TestGarbage1 s2=new TestGarbage1();
6. s1=null;
7. s2=null;
8. System.gc();
9. }
10. }
Test it Now
object is garbage collected
object is garbage collected

181) How is garbage collection controlled?

Garbage collection is managed by JVM. It is performed when there is not enough space in the memory
and memory is running low. We can externally call the System.gc() for the garbage collection. However,
it depends upon the JVM whether to perform it or not.

182) How can an object be unreferenced?

There are many ways:
• By nulling the reference
• By assigning a reference to another
• By anonymous object etc.

1) By nulling a reference:
1. Employee e=new Employee();
2. e=null;
2) By assigning a reference to another:
1. Employee e1=new Employee();
 2. Employee e2=new Employee();
3. e1=e2;//now the first object referred by e1 is available for garbage collection
3) By anonymous object:
1. new Employee();

183) What is the purpose of the finalize() method?

The finalize() method is invoked just before the object is garbage collected. It is used to perform cleanup
processing. The Garbage collector of JVM collects only those objects that are created by new keyword.
So if you have created an object without new, you can use the finalize method to perform cleanup
processing (destroying remaining objects). The cleanup processing is the process to free up all the
resources, network which was previously used and no longer needed. It is essential to remember that it
is not a reserved keyword, finalize method is present in the object class hence it is available in every
class as object class is the superclass of every class in java. Here, we must note that neither finalization
nor garbage collection is guaranteed. Consider the following example.
1. public class FinalizeTest {
2. int j=12;
3. void add()
4. {
5. j=j+12;
6. System.out.println("J="+j);
7. }
8. public void finalize()
9. {
10. System.out.println("Object is garbage collected");
11. }
12. public static void main(String[] args) {
13. new FinalizeTest().add();
14. System.gc();
15. new FinalizeTest().add();
16. }
17. }
18.

184) Can an unreferenced object be referenced again?

Yes,

185) What kind of thread is the Garbage collector thread?

Daemon thread.

186) What is the difference between final, finally and finalize?

No. final finally finalize
1) Final is used to apply restrictions on Finally is used to place Finalize is used to
class, method, and variable. The final important code, it will be perform clean up
class can't be inherited, final method executed whether an processing just before
can't be overridden, and final variable exception is handled or an object is garbage
value can't be changed. not. collected.
2) Final is a keyword. Finally is a block. Finalize is a method.

187) What is the purpose of the Runtime class?

Java Runtime class is used to interact with a java runtime environment. Java Runtime class provides
methods to execute a process, invoke GC, get total and free memory, etc. There is only one instance of
java.lang.Runtime class is available for one java application. The Runtime.getRuntime() method returns
the singleton instance of Runtime class.

188) How will you invoke any external process in Java?

By Runtime.getRuntime().exec(?) method. Consider the following example.
1. public class Runtime1{
2. public static void main(String args[])throws Exception{
3. Runtime.getRuntime().exec("notepad");//will open a new notepad
4. }
5. }

I/O Interview Questions

189) Give the hierarchy of InputStream and OutputStream classes.
OutputStream Hierarchy

InputStream Hierarchy

190) What do you understand by an IO stream?

The stream is a sequence of data that flows from source to destination. It is composed of bytes. In Java,
three streams are created for us automatically.
• System.out: standard output stream
• System.in: standard input stream
• System.err: standard error stream

191) What is the difference between the Reader/Writer class

hierarchy and the InputStream/OutputStream class hierarchy?
The Reader/Writer class hierarchy is character-oriented, and the InputStream/OutputStream class
hierarchy is byte-oriented. The ByteStream classes are used to perform input-output of 8-bit bytes
whereas the CharacterStream classes are used to perform the input/output for the 16-bit Unicode
system. There are many classes in the ByteStream class hierarchy, but the most frequently used classes
are FileInputStream and FileOutputStream. The most frequently used classes CharacterStream class
hierarchy is FileReader and FileWriter.

192) What are the super most classes for all the streams?
All the stream classes can be divided into two types of classes that are ByteStream classes and
CharacterStream Classes. The ByteStream classes are further divided into InputStream classes and
OutputStream classes. CharacterStream classes are also divided into Reader classes and Writer classes.
The SuperMost classes for all the InputStream classes is java.io.InputStream and for all the output
stream classes is java.io.OutPutStream. Similarly, for all the reader classes, the super-most class is
java.io.Reader, and for all the writer classes, it is java.io.Writer.

193) What are the FileInputStream and FileOutputStream?

Java FileOutputStream is an output stream used for writing data to a file. If you have some primitive
values to write into a file, use FileOutputStream class. You can write byte-oriented as well as character-
oriented data through the FileOutputStream class. However, for character-oriented data, it is preferred
to use FileWriter than FileOutputStream. Consider the following example of writing a byte into a file.
1. import java.io.FileOutputStream;
2. public class FileOutputStreamExample {
3. public static void main(String args[]){
4. try{
5. FileOutputStream fout=new FileOutputStream("D:\\testout.txt");
6. fout.write(65);
7. fout.close();
8. System.out.println("success...");
9. }catch(Exception e){System.out.println(e);}
10. }
11. }
Java FileInputStream class obtains input bytes from a file. It is used for reading byte-oriented data
(streams of raw bytes) such as image data, audio, video, etc. You can also read character-stream data.
However, for reading streams of characters, it is recommended to use FileReader class. Consider the
following example for reading bytes from a file.
1. import java.io.FileInputStream;
2. public class DataStreamExample {
3. public static void main(String args[]){
4. try{
5. FileInputStream fin=new FileInputStream("D:\\testout.txt");
6. int i=fin.read();
7. System.out.print((char)i);
8.
9. fin.close();
10. }catch(Exception e){System.out.println(e);}
11. }
12. }
13.

194) What is the purpose of using BufferedInputStream and

BufferedOutputStream classes?
Java BufferedOutputStream class is used for buffering an output stream. It internally uses a buffer to
store data. It adds more efficiency than to write data directly into a stream. So, it makes the
performance fast. Whereas, Java BufferedInputStream class is used to read information from the
stream. It internally uses the buffer mechanism to make the performance fast.

195) How to set the Permissions to a file in Java?

In Java, FilePermission class is used to alter the permissions set on a file. Java FilePermission class
contains the permission related to a directory or file. All the permissions are related to the path. The
path can be of two types:
• D:\\IO\\-: It indicates that the permission is associated with all subdirectories and files recursively.
• D:\\IO\\*: It indicates that the permission is associated with all directory and files within this
directory excluding subdirectories.
Let's see the simple example in which permission of a directory path is granted with read permission and
a file of this directory is granted for write permission.
1. package com.javatpoint;
2. import java.io.*;
3. import java.security.PermissionCollection;
4. public class FilePermissionExample{
5. public static void main(String[] args) throws IOException {
6. String srg = "D:\\IO Package\\java.txt";
7. FilePermission file1 = new FilePermission("D:\\IO Package\\-", "read");
8. PermissionCollection permission = file1.newPermissionCollection();
9. permission.add(file1);
10. FilePermission file2 = new FilePermission(srg, "write");
11. permission.add(file2);
12. if(permission.implies(new FilePermission(srg, "read,write"))) {
13. System.out.println("Read, Write permission is granted for the path "+srg );
14. }else {
15. System.out.println("No Read, Write permission is granted for the path "+srg); }
16. }
17. }
Output
Read, Write permission is granted for the path D:\IO Package\java.txt

196) What are FilterStreams?

FilterStream classes are used to add additional functionalities to the other stream classes. FilterStream
classes act like an interface which read the data from a stream, filters it, and pass the filtered data to the
caller. The FilterStream classes provide extra functionalities like adding line numbers to the destination
file, etc.

197) What is an I/O filter?

An I/O filter is an object that reads from one stream and writes to another, usually altering the data in
some way as it is passed from one stream to another. Many Filter classes that allow a user to make a
chain using multiple input streams. It generates a combined effect on several filters.

198) In Java, How many ways you can take input from the console?
In Java, there are three ways by using which, we can take input from the console.
• Using BufferedReader class: we can take input from the console by wrapping System.in into an
InputStreamReader and passing it into the BufferedReader. It provides an efficient reading as the
input gets buffered. Consider the following example.
1. import java.io.BufferedReader;
2. import java.io.IOException;
 3. import java.io.InputStreamReader;
4. public class Person
5. {
6. public static void main(String[] args) throws IOException
7. {
8. System.out.println("Enter the name of the person");
9. BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
10. String name = reader.readLine();
11. System.out.println(name);
12. }
13. }
• Using Scanner class: The Java Scanner class breaks the input into tokens using a delimiter that is
whitespace by default. It provides many methods to read and parse various primitive values. Java
Scanner class is widely used to parse text for string and primitive types using a regular expression.
Java Scanner class extends Object class and implements Iterator and Closeable interfaces.
Consider the following example.
1. import java.util.*;
2. public class ScannerClassExample2 {
3. public static void main(String args[]){
4. String str = "Hello/This is JavaTpoint/My name is Abhishek.";
5. //Create scanner with the specified String Object
6. Scanner scanner = new Scanner(str);
7. System.out.println("Boolean Result: "+scanner.hasNextBoolean());
8. //Change the delimiter of this scanner
9. scanner.useDelimiter("/");
10. //Printing the tokenized Strings
11. System.out.println("---Tokenizes String---");
12. while(scanner.hasNext()){
13. System.out.println(scanner.next());
14. }
15. //Display the new delimiter
16. System.out.println("Delimiter used: " +scanner.delimiter());
17. scanner.close();
18. }
19. }
20.
• Using Console class: The Java Console class is used to get input from the console. It provides
methods to read texts and passwords. If you read the password using the Console class, it will not
be displayed to the user. The java.io.Console class is attached to the system console internally.
The Console class is introduced since 1.5. Consider the following example.
1. import java.io.Console;
2. class ReadStringTest{
3. public static void main(String args[]){
4. Console c=System.console();
5. System.out.println("Enter your name: ");
6. String n=c.readLine();
7. System.out.println("Welcome "+n);
8. }
9. }

Serialization Interview Questions

199) What is serialization?
Serialization in Java is a mechanism of writing the state of an object into a byte stream. It is used
primarily in Hibernate, RMI, JPA, EJB and JMS technologies. It is mainly used to travel object's state on
the network (which is known as marshaling). Serializable interface is used to perform serialization. It is
helpful when you require to save the state of a program to storage such as the file. At a later point of
time, the content of this file can be restored using deserialization. It is also required to implement
RMI(Remote Method Invocation). With the help of RMI, it is possible to invoke the method of a Java
object on one machine to another machine.

More details.

200) How can you make a class serializable in Java?

A class can become serializable by implementing the Serializable interface.

201) How can you avoid serialization in child class if the base class is
implementing the Serializable interface?
It is very tricky to prevent serialization of child class if the base class is intended to implement the
Serializable interface. However, we cannot do it directly, but the serialization can be avoided by
implementing the writeObject() or readObject() methods in the subclass and throw
NotSerializableException from these methods. Consider the following example.
1. import java.io.FileInputStream;
2. import java.io.FileOutputStream;
3. import java.io.IOException;
4. import java.io.NotSerializableException;
5. import java.io.ObjectInputStream;
6. import java.io.ObjectOutputStream;
7. import java.io.Serializable;
8. class Person implements Serializable
9. {
10. String name = " ";
11. public Person(String name)
12. {
13. this.name = name;
14. }
15. }
16. class Employee extends Person
17. {
18. float salary;
19. public Employee(String name, float salary)
20. {
21. super(name);
22. this.salary = salary;
23. }
24. private void writeObject(ObjectOutputStream out) throws IOException
25. {
26. throw new NotSerializableException();
27. }
28. private void readObject(ObjectInputStream in) throws IOException
29. {
30. throw new NotSerializableException();
31. }
32.
33. }
34. public class Test
35. {
36. public static void main(String[] args)
37. throws Exception
38. {
39. Employee emp = new Employee("Sharma", 10000);
40.
41. System.out.println("name = " + emp.name);
42. System.out.println("salary = " + emp.salary);
43.
44. FileOutputStream fos = new FileOutputStream("abc.ser");
45. ObjectOutputStream oos = new ObjectOutputStream(fos);
46.
47. oos.writeObject(emp);
48.
49. oos.close();
50. fos.close();
51.
52. System.out.println("Object has been serialized");
53.
54. FileInputStream f = new FileInputStream("ab.txt");
55. ObjectInputStream o = new ObjectInputStream(f);
56.
57. Employee emp1 = (Employee)o.readObject();
58.
59. o.close();
60. f.close();
61.
62. System.out.println("Object has been deserialized");
63.
64. System.out.println("name = " + emp1.name);
65. System.out.println("salary = " + emp1.salary);
66. }
67. }
202) Can a Serialized object be transferred via network?
Yes, we can transfer a serialized object via network because the serialized object is stored in the
memory in the form of bytes and can be transmitted over the network. We can also write the serialized
object to the disk or the database.

203) What is Deserialization?

Deserialization is the process of reconstructing the object from the serialized state. It is the reverse
operation of serialization. An ObjectInputStream deserializes objects and primitive data written using an
ObjectOutputStream.
1. import java.io.*;
2. class Depersist{
3. public static void main(String args[])throws Exception{
4.
5. ObjectInputStream in=new ObjectInputStream(new FileInputStream("f.txt"));
6. Student s=(Student)in.readObject();
7. System.out.println(s.id+" "+s.name);
8.
9. in.close();
10. }
11. }
211 ravi

204) What is the transient keyword?

If you define any data member as transient, it will not be serialized. By determining transient keyword,
the value of variable need not persist when it is restored. More details.

205) What is Externalizable?

The Externalizable interface is used to write the state of an object into a byte stream in a compressed
format. It is not a marker interface.

206) What is the difference between Serializable and Externalizable

interface?

No. Serializable Externalizable

1) The Serializable interface does not have The Externalizable interface contains is not a marker
any method, i.e., it is a marker interface, It contains two methods, i.e.,
interface. writeExternal() and readExternal().
2) It is used to "mark" Java classes so that The Externalizable interface provides control of the
objects of these classes may get the serialization logic to the programmer.
certain capability.
3) It is easy to implement but has the It is used to perform the serialization and often
higher performance cost. result in better performance.
4) No class constructor is called in We must call a public default constructor while
serialization. using this interface.
.

Networking Interview Questions

207) Give a brief description of Java socket programming?
Java Socket programming is used for communication between the applications running on different JRE.
Java Socket programming can be connection-oriented or connectionless. Socket and ServerSocket
classes are used for connection-oriented socket programming and DatagramSocket, and
DatagramPacket classes are used for connectionless socket programming. The client in socket
programming must know two information:
• IP address of the server
• port number

208) What is Socket?

A socket is simply an endpoint for communications between the machines. It provides the connection
mechanism to connect the two computers using TCP. The Socket class can be used to create a socket.

209) What are the steps that are followed when two computers
connect through TCP?
There are the following steps that are performed when two computers connect through TCP.
• The ServerSocket object is instantiated by the server which denotes the port number to which, the
connection will be made.
• After instantiating the ServerSocket object, the server invokes accept() method of ServerSocket
class which makes server wait until the client attempts to connect to the server on the given port.
• Meanwhile, the server is waiting, a socket is created by the client by instantiating Socket class. The
socket class constructor accepts the server port number and server name.
• The Socket class constructor attempts to connect with the server on the specified name. If the
connection is established, the client will have a socket object that can communicate with the
server.
• The accept() method invoked by the server returns a reference to the new socket on the server
that is connected with the server.

210) Write a program in Java to establish a connection between client

and server?
Consider the following program where the connection between the client and server is established.
File: MyServer.java
1. import java.io.*;
2. import java.net.*;
3. public class MyServer {
4. public static void main(String[] args){
5. try{
6. ServerSocket ss=new ServerSocket(6666);
7. Socket s=ss.accept();//establishes connection
8. DataInputStream dis=new DataInputStream(s.getInputStream());
9. String str=(String)dis.readUTF();
10. System.out.println("message= "+str);
11. ss.close();
12. }catch(Exception e){System.out.println(e);}
13. }
14. }
File: MyClient.java
1. import java.io.*;
2. import java.net.*;
 3. public class MyClient {
4. public static void main(String[] args) {
5. try{
6. Socket s=new Socket("localhost",6666);
7. DataOutputStream dout=new DataOutputStream(s.getOutputStream());
8. dout.writeUTF("Hello Server");
9. dout.flush();
10. dout.close();
11. s.close();
12. }catch(Exception e){System.out.println(e);}
13. }
14. }

211) How do I convert a numeric IP address like 192.18.97.39 into a

hostname like java.sun.com?
By InetAddress.getByName("192.18.97.39").getHostName() where 192.18.97.39 is the IP address.
Consider the following example.
1. import java.io.*;
2. import java.net.*;
3. public class InetDemo{
4. public static void main(String[] args){
5. try{
6. InetAddress ip=InetAddress.getByName("195.201.10.8");
7.
8. System.out.println("Host Name: "+ip.getHostName());
9. }catch(Exception e){System.out.println(e);}
10. }
11. }
12.

Reflection Interview Questions

212) What is the reflection?
Reflection is the process of examining or modifying the runtime behavior of a class at runtime. The
java.lang.Class class provides various methods that can be used to get metadata, examine and change
the runtime behavior of a class. The java.lang and java.lang.reflect packages provide classes for java
reflection. It is used in:
• IDE (Integrated Development Environment), e.g., Eclipse, MyEclipse, NetBeans.
• Debugger
• Test Tools, etc.

213) What is the purpose of using java.lang.Class class?

The java.lang.Class class performs mainly two tasks:
• Provides methods to get the metadata of a class at runtime.
• Provides methods to examine and change the runtime behavior of a class.

214) What are the ways to instantiate the Class class?

There are three ways to instantiate the Class class.
• forName() method of Class class: The forName() method is used to load the class dynamically. It
returns the instance of Class class. It should be used if you know the fully qualified name of the
 class. This cannot be used for primitive types.
• getClass() method of Object class: It returns the instance of Class class. It should be used if you
know the type. Moreover, it can be used with primitives.
• the .class syntax: If a type is available, but there is no instance then it is possible to obtain a Class
by appending ".class" to the name of the type. It can be used for primitive data type also.

215) What is the output of the following Java program?

1. class Simple{
2. public Simple()
3. {
4. System.out.println("Constructor of Simple class is invoked");
5. }
6. void message(){System.out.println("Hello Java");}
7. }
8.
9. class Test1{
10. public static void main(String args[]){
11. try{
12. Class c=Class.forName("Simple");
13. Simple s=(Simple)c.newInstance();
14. s.message();
15. }catch(Exception e){System.out.println(e);}
16. }
17. }
Output
Constructor of Simple class is invoked
Hello Java
Explanation
The newInstance() method of the Class class is used to invoke the constructor at runtime. In this
program, the instance of the Simple class is created.

216) What is the purpose of using javap?

The javap command disassembles a class file. The javap command displays information about the fields,
constructors and methods present in a class file.
Syntax
javap fully_class_name

217) Can you access the private method from outside the class?
Yes, by changing the runtime behavior of a class if the class is not secured.
More details.

Miscellaneous Interview Questions

218)What are wrapper classes?
Wrapper classes are classes that allow primitive types to be accessed as objects. In other words, we can
say that wrapper classes are built-in java classes which allow the conversion of objects to primitives and
primitives to objects. The process of converting primitives to objects is called autoboxing, and the
process of converting objects to primitives is called unboxing. There are eight wrapper classes present in
java.lang package is given below.
Primitive Type Wrapper class
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double

219)What are autoboxing and unboxing? When does it occur?

The autoboxing is the process of converting primitive data type to the corresponding wrapper class
object, eg., int to Integer. The unboxing is the process of converting wrapper class object to primitive
data type. For eg., integer to int. Unboxing and autoboxing occur automatically in Java. However, we can
externally convert one into another by using the methods like valueOf() or xxxValue().
It can occur whenever a wrapper class object is expected, and primitive data type is provided or vice
versa.
• Adding primitive types into Collection like ArrayList in Java.
• Creating an instance of parameterized classes ,e.g., ThreadLocal which expect Type.
• Java automatically converts primitive to object whenever one is required and another is provided
in the method calling.
• When a primitive type is assigned to an object type.

220) What is the output of the below Java program?

1. public class Test1
2. {
3. public static void main(String[] args) {
4. Integer i = new Integer(201);
5. Integer j = new Integer(201);
6. if(i == j)
7. {
8. System.out.println("hello");
9. }
10. else
11. {
12. System.out.println("bye");
13. }
14. }
15. }
Output
bye
Explanation
The Integer class caches integer values from -127 to 127. Therefore, the Integer objects can only be
created in the range -128 to 127. The operator == will not work for the value greater than 127; thus bye
is printed.

221) What is object cloning?

The object cloning is a way to create an exact copy of an object. The clone() method of the Object class
is used to clone an object. The java.lang.Cloneable interface must be implemented by the class whose
object clone we want to create. If we don't implement Cloneable interface, clone() method generates
CloneNotSupportedException. The clone() method is defined in the Object class. The syntax of the
clone() method is as follows:
protected Object clone() throws CloneNotSupportedException

222) What are the advantages and disadvantages of object cloning?

Advantage of Object Cloning
• You don't need to write lengthy and repetitive codes. Just use an abstract class with a 4- or 5-line
long clone() method.
• It is the easiest and most efficient way of copying objects, especially if we are applying it to an
already developed or an old project. Just define a parent class, implement Cloneable in it, provide
the definition of the clone() method and the task will be done.
• Clone() is the fastest way to copy the array.
Disadvantage of Object Cloning
• To use the Object.clone() method, we have to change many syntaxes to our code, like
implementing a Cloneable interface, defining the clone() method and handling
CloneNotSupportedException, and finally, calling Object.clone(), etc.
• We have to implement the Cloneable interface while it does not have any methods in it. We have
to use it to tell the JVM that we can perform a clone() on our object.
• Object.clone() is protected, so we have to provide our own clone() and indirectly call
Object.clone() from it.
• Object.clone() does not invoke any constructor, so we do not have any control over object
construction.
• If you want to write a clone method in a child class, then all of its superclasses should define the
clone() method in them or inherit it from another parent class. Otherwise, the super.clone() chain
will fail.
• Object.clone() supports only shallow copying, but we will need to override it if we need deep
cloning.

223) What is a native method?

A native method is a method that is implemented in a language other than Java. Natives methods are
sometimes also referred to as foreign methods.

224) What is the purpose of the strictfp keyword?

Java strictfp keyword ensures that you will get the same result on every platform if you perform
operations in the floating-point variable. The precision may differ from platform to platform that is why
java programming language has provided the strictfp keyword so that you get the same result on every
platform. So, now you have better control over the floating-point arithmetic.

225) What is the purpose of the System class?

The purpose of the System class is to provide access to system resources such as standard input and
output. It cannot be instantiated. Facilities provided by System class are given below.
• Standard input
• Error output streams
• Standard output
• utility method to copy the portion of an array
• utilities to load files and libraries
There are the three fields of Java System class, i.e., static printstream err, static inputstream in, and
standard output stream.

226) What comes to mind when someone mentions a shallow copy in

Java?
Object cloning.

227) What is a singleton class?

Singleton class is the class which can not be instantiated more than once. To make a class singleton, we
either make its constructor private or use the static getInstance method. Consider the following
example.
1. class Singleton{
2. private static Singleton single_instance = null;
3. int i;
4. private Singleton ()
5. {
6. i=90;
7. }
8. public static Singleton getInstance()
9. {
10. if(single_instance == null)
11. {
12. single_instance = new Singleton();
13. }
14. return single_instance;
15. }
16. }
17. public class Main
18. {
19. public static void main (String args[])
20. {
21. Singleton first = Singleton.getInstance();
22. System.out.println("First instance integer value:"+first.i);
23. first.i=first.i+90;
24. Singleton second = Singleton.getInstance();
25. System.out.println("Second instance integer value:"+second.i);
26. }
27. }
28.

228) Write a Java program that prints all the values given at
command-line.
Program
1. class A{
2. public static void main(String args[]){
3.
4. for(int i=0;i<args.length;i++)
5. System.out.println(args[i]);
6.
7. }
8. }
9. compile by > javac A.java
10. run by > java A sonoo jaiswal 1 3 abc
Output
sonoo
jaiswal
1
3
abc

229) Which containers use a border layout as their default layout?

The Window, Frame and Dialog classes use a border layout as their default layout.

230) Which containers use a FlowLayout as their default layout?

The Panel and Applet classes use the FlowLayout as their default layout.

231) What are peerless components?

The lightweight component of Swing is called peerless components. Spring has its libraries, so it does
not use resources from the Operating System, and hence it has lightweight components.

232) is there is any difference between a Scrollbar and a ScrollPane?

The Scrollbar is a Component whereas the ScrollPane is a Container. A ScrollPane handles its events and
performs its scrolling.

233) What is a lightweight component?

Lightweight components are the one which does not go with the native call to obtain the graphical units.
They share their parent component graphical units to render them. For example, Swing components,
and JavaFX Components.

234) What is a heavyweight component?

The portable elements provided by the operating system are called heavyweight components. AWT is
limited to the graphical classes provided by the operating system and therefore, It implements only the
minimal subset of screen elements supported by all platforms. The Operating system dependent UI
discovery tools are called heavyweight components.

235) What is an applet?

An applet is a small java program that runs inside the browser and generates dynamic content. It is
embedded in the webpage and runs on the client side. It is secured and takes less response time. It can
be executed by browsers running under many platforms, including Linux, Windows, Mac Os, etc.
However, the plugins are required at the client browser to execute the applet. The following image
shows the architecture of Applet.
When an applet is created, the following methods are invoked in order.
• init()
• start()
• paint()
When an applet is destroyed, the following functions are invoked in order.
• stop()
• destroy()

236) Can you write a Java class that could be used both as an applet as
well as an application?
Yes. Add a main() method to the applet.

Internationalization Interview Questions

237) What is Locale?
A Locale object represents a specific geographical, political, or cultural region. This object can be used to
get the locale-specific information such as country name, language, variant, etc.
1. import java.util.*;
2. public class LocaleExample {
3. public static void main(String[] args) {
4. Locale locale=Locale.getDefault();
5. //Locale locale=new Locale("fr","fr");//for the specific locale
6.
7. System.out.println(locale.getDisplayCountry());
8. System.out.println(locale.getDisplayLanguage());
 9. System.out.println(locale.getDisplayName());
10. System.out.println(locale.getISO3Country());
11. System.out.println(locale.getISO3Language());
12. System.out.println(locale.getLanguage());
13. System.out.println(locale.getCountry());
14.
15. }
16. }
Output:
United States
English
English (United States)
USA
eng
en
US

238)How will you load a specific locale?

By ResourceBundle.getBundle(?) method.

Java Bean Interview Questions

239) What is a JavaBean?
JavaBean is a reusable software component written in the Java programming language, designed to be
manipulated visually by a software development environment, like JBuilder or VisualAge for Java. t. A
JavaBean encapsulates many objects into one object so that we can access this object from multiple
places. Moreover, it provides the easy maintenance. Consider the following example to create a
JavaBean class.
1. //Employee.java
2. package mypack;
3. public class Employee implements java.io.Serializable{
4. private int id;
5. private String name;
6. public Employee(){}
7. public void setId(int id){this.id=id;}
8. public int getId(){return id;}
9. public void setName(String name){this.name=name;}
10. public String getName(){return name;}
11. }

240) What is the purpose of using the Java bean?

According to Java white paper, it is a reusable software component. A bean encapsulates many objects
into one object so that we can access this object from multiple places. Moreover, it provides the easy
maintenance.

241) What do you understand by the bean persistent property?

The persistence property of Java bean comes into the act when the properties, fields, and state
information are saved to or retrieve from the storage.

RMI Interview Questions

242) What is RMI?
The RMI (Remote Method Invocation) is an API that provides a mechanism to create the distributed
application in java. The RMI allows an object to invoke methods on an object running in another JVM.
The RMI provides remote communication between the applications using two objects stub and skeleton.

243) What is the purpose of stub and skeleton?

Stub
The stub is an object, acts as a gateway for the client side. All the outgoing requests are routed through
it. It resides at the client side and represents the remote object. When the caller invokes the method on
the stub object, it does the following tasks:
• It initiates a connection with remote Virtual Machine (JVM).
• It writes and transmits (marshals) the parameters to the remote Virtual Machine (JVM).
• It waits for the result.
• It reads (unmarshals) the return value or exception.
• It finally, returns the value to the caller.
Skeleton
The skeleton is an object, acts as a gateway for the server side object. All the incoming requests are
routed through it. When the skeleton receives the incoming request, it does the following tasks:
• It reads the parameter for the remote method.
• It invokes the method on the actual remote object.
• It writes and transmits (marshals) the result to the caller.

244) What are the steps involved to write RMI based programs?
There are 6 steps which are performed to write RMI based programs.
• Create the remote interface.
• Provide the implementation of the remote interface.
• Compile the implementation class and create the stub and skeleton objects using the rmic tool.
• Start the registry service by the rmiregistry tool.
• Create and start the remote application.
• Create and start the client application.

245) What is the use of HTTP-tunneling in RMI?

HTTP tunneling can be defined as the method which doesn't need any setup to work within the firewall
environment. It handles the HTTP connections through the proxy servers. However, it does not allow
outbound TCP connections.

246) What is JRMP?

JRMP (Java Remote Method Protocol) can be defined as the Java-specific, stream-based protocol which
looks up and refers to the remote objects. It requires both client and server to use Java objects. It is wire
level protocol which runs under RMI and over TCP/IP.

247) Can RMI and CORBA based applications interact?

Yes, they can. RMI is available with IIOP as the transport protocol instead of JRMP.

Core Java: Data Structure interview questions

248) How to perform Bubble Sort in Java?
Consider the following program to perform Bubble sort in Java.
 1. public class BubbleSort {
2. public static void main(String[] args) {
3. int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};
4. for(int i=0;i<10;i++)
5. {
6. for (int j=0;j<10;j++)
7. {
8. if(a[i]<a[j])
9. {
10. int temp = a[i];
11. a[i]=a[j];
12. a[j] = temp;
13. }
14. }
15. }
16. System.out.println("Printing Sorted List ...");
17. for(int i=0;i<10;i++)
18. {
19. System.out.println(a[i]);
20. }
21. }
22. }
Output:
Printing Sorted List . . .
7
9
10
12
23
34
34
44
78
101

249) How to perform Binary Search in Java?

Consider the following program to perform the binary search in Java.
1. import java.util.*;
2. public class BinarySearch {
3. public static void main(String[] args) {
4. int[] arr = {16, 19, 20, 23, 45, 56, 78, 90, 96, 100};
5. int item, location = -1;
6. System.out.println("Enter the item which you want to search");
7. Scanner sc = new Scanner(System.in);
8. item = sc.nextInt();
9. location = binarySearch(arr,0,9,item);
10. if(location != -1)
11. System.out.println("the location of the item is "+location);
12. else
13. System.out.println("Item not found");
14. }
15. public static int binarySearch(int[] a, int beg, int end, int item)
16. {
 17. int mid;
18. if(end >= beg)
19. {
20. mid = (beg + end)/2;
21. if(a[mid] == item)
22. {
23. return mid+1;
24. }
25. else if(a[mid] < item)
26. {
27. return binarySearch(a,mid+1,end,item);
28. }
29. else
30. {
31. return binarySearch(a,beg,mid-1,item);
32. }
33. }
34. return -1;
35. }
36. }
Output:
Enter the item which you want to search
45
the location of the item is 5

250) How to perform Selection Sort in Java?

Consider the following program to perform selection sort in Java.
1. public class SelectionSort {
2. public static void main(String[] args) {
3. int[] a = {10, 9, 7, 101, 23, 44, 12, 78, 34, 23};
4. int i,j,k,pos,temp;
5. for(i=0;i<10;i++)
6. {
7. pos = smallest(a,10,i);
8. temp = a[i];
9. a[i]=a[pos];
10. a[pos] = temp;
11. }
12. System.out.println("\nprinting sorted elements...\n");
13. for(i=0;i<10;i++)
14. {
15. System.out.println(a[i]);
16. }
17. }
18. public static int smallest(int a[], int n, int i)
19. {
20. int small,pos,j;
21. small = a[i];
22. pos = i;
23. for(j=i+1;j<10;j++)
24. {
25. if(a[j]<small)
26. {
 27. small = a[j];
28. pos=j;
29. }
30. }
31. return pos;
32. }
33. }
Output:
printing sorted elements...
7
9
10
12
23
23
34
44
78
101

251) How to perform Linear Search in Java?

Consider the following program to perform Linear search in Java.
1. import java.util.Scanner;
2.
3. public class Leniear_Search {
4. public static void main(String[] args) {
5. int[] arr = {10, 23, 15, 8, 4, 3, 25, 30, 34, 2, 19};
6. int item,flag=0;
7. Scanner sc = new Scanner(System.in);
8. System.out.println("Enter Item ?");
9. item = sc.nextInt();
10. for(int i = 0; i<10; i++)
11. {
12. if(arr[i]==item)
13. {
14. flag = i+1;
15. break;
16. }
17. else
18. flag = 0;
19. }
20. if(flag != 0)
21. {
22. System.out.println("Item found at location" + flag);
23. }
24. else
25. System.out.println("Item not found");
26.
27. }
28. }
Output:
Enter Item ?
23
Item found at location 2
Enter Item ?
22
Item not found

252) How to perform merge sort in Java?

Consider the following program to perform merge sort in Java.
1. public class MyMergeSort
2. {
3. void merge(int arr[], int beg, int mid, int end)
4. {
5.
6. int l = mid - beg + 1;
7. int r = end - mid;
8.
9. intLeftArray[] = new int [l];
10. intRightArray[] = new int [r];
11.
12. for (int i=0; i<l; ++i)
13. LeftArray[i] = arr[beg + i];
14.
15. for (int j=0; j<r; ++j)
16. RightArray[j] = arr[mid + 1+ j];
17.
18.
19. int i = 0, j = 0;
20. int k = beg;
21. while (i<l&&j<r)
22. {
23. if (LeftArray[i] <= RightArray[j])
24. {
25. arr[k] = LeftArray[i];
26. i++;
27. }
28. else
29. {
30. arr[k] = RightArray[j];
31. j++;
32. }
33. k++;
34. }
35. while (i<l)
36. {
37. arr[k] = LeftArray[i];
38. i++;
39. k++;
40. }
41.
42. while (j<r)
43. {
44. arr[k] = RightArray[j];
45. j++;
46. k++;
 47. }
48. }
49.
50. void sort(int arr[], int beg, int end)
51. {
52. if (beg<end)
53. {
54. int mid = (beg+end)/2;
55. sort(arr, beg, mid);
56. sort(arr , mid+1, end);
57. merge(arr, beg, mid, end);
58. }
59. }
60. public static void main(String args[])
61. {
62. intarr[] = {90,23,101,45,65,23,67,89,34,23};
63. MyMergeSort ob = new MyMergeSort();
64. ob.sort(arr, 0, arr.length-1);
65.
66. System.out.println("\nSorted array");
67. for(int i =0; i<arr.length;i++)
68. {
69. System.out.println(arr[i]+"");
70. }
71. }
72. }
Output:
Sorted array
23
23
23
34
45
65
67
89
90
101

253) How to perform quicksort in Java?

Consider the following program to perform quicksort in Java.
1. public class QuickSort {
2. public static void main(String[] args) {
3. int i;
4. int[] arr={90,23,101,45,65,23,67,89,34,23};
5. quickSort(arr, 0, 9);
6. System.out.println("\n The sorted array is: \n");
7. for(i=0;i<10;i++)
8. System.out.println(arr[i]);
9. }
10. public static int partition(int a[], int beg, int end)
11. {
12.
 13. int left, right, temp, loc, flag;
14. loc = left = beg;
15. right = end;
16. flag = 0;
17. while(flag != 1)
18. {
19. while((a[loc] <= a[right]) && (loc!=right))
20. right--;
21. if(loc==right)
22. flag =1;
23. elseif(a[loc]>a[right])
24. {
25. temp = a[loc];
26. a[loc] = a[right];
27. a[right] = temp;
28. loc = right;
29. }
30. if(flag!=1)
31. {
32. while((a[loc] >= a[left]) && (loc!=left))
33. left++;
34. if(loc==left)
35. flag =1;
36. elseif(a[loc] <a[left])
37. {
38. temp = a[loc];
39. a[loc] = a[left];
40. a[left] = temp;
41. loc = left;
42. }
43. }
44. }
45. returnloc;
46. }
47. static void quickSort(int a[], int beg, int end)
48. {
49.
50. int loc;
51. if(beg<end)
52. {
53. loc = partition(a, beg, end);
54. quickSort(a, beg, loc-1);
55. quickSort(a, loc+1, end);
56. }
57. }
58. }
Output:
The sorted array is:
23
23
23
34
45
65
67
89
90
101

254) Write a program in Java to create a doubly linked list containing

n nodes.
Consider the following program to create a doubly linked list containing n nodes.
1. public class CountList {
2.
3. //Represent a node of the doubly linked list
4.
5. class Node{
6. int data;
7. Node previous;
8. Node next;
9.
10. public Node(int data) {
11. this.data = data;
12. }
13. }
14.
15. //Represent the head and tail of the doubly linked list
16. Node head, tail = null;
17.
18. //addNode() will add a node to the list
19. public void addNode(int data) {
20. //Create a new node
21. Node newNode = new Node(data);
22.
23. //If list is empty
24. if(head == null) {
25. //Both head and tail will point to newNode
26. head = tail = newNode;
27. //head's previous will point to null
28. head.previous = null;
29. //tail's next will point to null, as it is the last node of the list
30. tail.next = null;
31. }
32. else {
33. //newNode will be added after tail such that tail's next will point to newNode
34. tail.next = newNode;
35. //newNode's previous will point to tail
36. newNode.previous = tail;
37. //newNode will become new tail
38. tail = newNode;
39. //As it is last node, tail's next will point to null
40. tail.next = null;
41. }
42. }
43.
 44. //countNodes() will count the nodes present in the list
45. public int countNodes() {
46. int counter = 0;
47. //Node current will point to head
48. Node current = head;
49.
50. while(current != null) {
51. //Increment the counter by 1 for each node
52. counter++;
53. current = current.next;
54. }
55. return counter;
56. }
57.
58. //display() will print out the elements of the list
59. public void display() {
60. //Node current will point to head
61. Node current = head;
62. if(head == null) {
63. System.out.println("List is empty");
64. return;
65. }
66. System.out.println("Nodes of doubly linked list: ");
67. while(current != null) {
68. //Prints each node by incrementing the pointer.
69.
70. System.out.print(current.data + " ");
71. current = current.next;
72. }
73. }
74.
75. public static void main(String[] args) {
76.
77. CountList dList = new CountList();
78. //Add nodes to the list
79. dList.addNode(1);
80. dList.addNode(2);
81. dList.addNode(3);
82. dList.addNode(4);
83. dList.addNode(5);
84.
85. //Displays the nodes present in the list
86. dList.display();
87.
88. //Counts the nodes present in the given list
89. System.out.println("\nCount of nodes present in the list: " + dList.countNodes());
90. }
91. }
Output:
Nodes of doubly linked list:
12345
Count of nodes present in the list: 5
255) Write a program in Java to find the maximum and minimum
value node from a circular linked list.
Consider the following program.
1. public class MinMax {
2. //Represents the node of list.
3. public class Node{
4. int data;
5. Node next;
6. public Node(int data) {
7. this.data = data;
8. }
9. }
10.
11. //Declaring head and tail pointer as null.
12. public Node head = null;
13. public Node tail = null;
14.
15. //This function will add the new node at the end of the list.
16. public void add(int data){
17. //Create new node
18. Node newNode = new Node(data);
19. //Checks if the list is empty.
20. if(head == null) {
21. //If list is empty, both head and tail would point to new node.
22. head = newNode;
23. tail = newNode;
24. newNode.next = head;
25. }
26. else {
27. //tail will point to new node.
28. tail.next = newNode;
29. //New node will become new tail.
30. tail = newNode;
31. //Since, it is circular linked list tail will points to head.
32. tail.next = head;
33. }
34. }
35.
36. //Finds out the minimum value node in the list
37. public void minNode() {
38. Node current = head;
39. //Initializing min to initial node data
40. int min = head.data;
41. if(head == null) {
42. System.out.println("List is empty");
43. }
44. else {
45. do{
46. //If current node's data is smaller than min
47. //Then replace value of min with current node's data
48. if(min > current.data) {
49. min = current.data;
 50. }
51. current= current.next;
52. }while(current != head);
53.
54. System.out.println("Minimum value node in the list: "+ min);
55. }
56. }
57.
58. //Finds out the maximum value node in the list
59. public void maxNode() {
60. Node current = head;
61. //Initializing max to initial node data
62. int max = head.data;
63. if(head == null) {
64. System.out.println("List is empty");
65. }
66. else {
67. do{
68. //If current node's data is greater than max
69. //Then replace value of max with current node's data
70. if(max < current.data) {
71. max = current.data;
72. }
73. current= current.next;
74. }while(current != head);
75.
76. System.out.println("Maximum value node in the list: "+ max);
77. }
78. }
79.
80. public static void main(String[] args) {
81. MinMax cl = new MinMax();
82. //Adds data to the list
83. cl.add(5);
84. cl.add(20);
85. cl.add(10);
86. cl.add(1);
87. //Prints the minimum value node in the list
88. cl.minNode();
89. //Prints the maximum value node in the list
90. cl.maxNode();
91. }
92. }
Output:
Minimum value node in the list: 1
Maximum value node in the list: 20

256) Write a program in Java to calculate the difference between the

sum of the odd level and even level nodes of a Binary Tree.
Consider the following program.
1. import java.util.LinkedList;
2. import java.util.Queue;
 3.
4. public class DiffOddEven {
5.
6. //Represent a node of binary tree
7. public static class Node{
8. int data;
9. Node left;
10. Node right;
11.
12. public Node(int data){
13. //Assign data to the new node, set left and right children to null
14. this.data = data;
15. this.left = null;
16. this.right = null;
17. }
18. }
19.
20. //Represent the root of binary tree
21. public Node root;
22.
23. public DiffOddEven(){
24. root = null;
25. }
26.
27. //difference() will calculate the difference between sum of odd and even levels of binary tree
28. public int difference() {
29. int oddLevel = 0, evenLevel = 0, diffOddEven = 0;
30.
31. //Variable nodesInLevel keep tracks of number of nodes in each level
32. int nodesInLevel = 0;
33.
34. //Variable currentLevel keep track of level in binary tree
35. int currentLevel = 0;
36.
37. //Queue will be used to keep track of nodes of tree level-wise
38. Queue<Node> queue = new LinkedList<Node>();
39.
40. //Check if root is null
41. if(root == null) {
42. System.out.println("Tree is empty");
43. return 0;
44. }
45. else {
46. //Add root node to queue as it represents the first level
47. queue.add(root);
48. currentLevel++;
49.
50. while(queue.size() != 0) {
51.
52. //Variable nodesInLevel will hold the size of queue i.e. number of elements in queue
53. nodesInLevel = queue.size();
54.
55. while(nodesInLevel > 0) {
 56. Node current = queue.remove();
57.
58. //Checks if currentLevel is even or not.
59. if(currentLevel % 2 == 0)
60. //If level is even, add nodes's to variable evenLevel
61. evenLevel += current.data;
62. else
63. //If level is odd, add nodes's to variable oddLevel
64. oddLevel += current.data;
65.
66. //Adds left child to queue
67. if(current.left != null)
68. queue.add(current.left);
69. //Adds right child to queue
70. if(current.right != null)
71. queue.add(current.right);
72. nodesInLevel--;
73. }
74. currentLevel++;
75. }
76. //Calculates difference between oddLevel and evenLevel
77. diffOddEven = Math.abs(oddLevel - evenLevel);
78. }
79. return diffOddEven;
80. }
81.
82. public static void main (String[] args) {
83.
84. DiffOddEven bt = new DiffOddEven();
85. //Add nodes to the binary tree
86. bt.root = new Node(1);
87. bt.root.left = new Node(2);
88. bt.root.right = new Node(3);
89. bt.root.left.left = new Node(4);
90. bt.root.right.left = new Node(5);
91. bt.root.right.right = new Node(6);
92.
93. //Display the difference between sum of odd level and even level nodes
94. System.out.println("Difference between sum of odd level and even level nodes: " + bt.differen
ce());
95. }
96. }
Output:
Difference between sum of odd level and even level nodes: 11

From <https://www.javatpoint.com/corejava-interview-questions-2>

Multithreading Interview Questions

1) What is multithreading?
Multithreading is a process of executing multiple threads simultaneously. Multithreading is used to
obtain the multitasking. It consumes less memory and gives the fast and efficient performance. Its main
advantages are:
 • Threads share the same address space.
• The thread is lightweight.
• The cost of communication between the processes is low.
More details.

2) What is the thread?

A thread is a lightweight subprocess. It is a separate path of execution because each thread runs in a
different stack frame. A process may contain multiple threads. Threads share the process resources, but
still, they execute independently.
More details.

3) Differentiate between process and thread?

There are the following differences between the process and thread.

• A Program in the execution is called the process whereas; A thread is a subset of the process
• Processes are independent whereas threads are the subset of process.
• Process have different address space in memory, while threads contain a shared address space.
• Context switching is faster between the threads as compared to processes.
• Inter-process communication is slower and expensive than inter-thread communication.
• Any change in Parent process doesn't affect the child process whereas changes in parent thread
can affect the child thread.
4) What do you understand by inter-thread communication?
• The process of communication between synchronized threads is termed as inter-thread
communication.
• Inter-thread communication is used to avoid thread polling in Java.
• The thread is paused running in its critical section, and another thread is allowed to enter (or lock)
in the same critical section to be executed.
• It can be obtained by wait(), notify(), and notifyAll() methods.

5) What is the purpose of wait() method in Java?

The wait() method is provided by the Object class in Java. This method is used for inter-thread
communication in Java. The java.lang.Object.wait() is used to pause the current thread, and wait until
another thread does not call the notify() or notifyAll() method. Its syntax is given below.
public final void wait()

6) Why must wait() method be called from the synchronized block?

We must call the wait method otherwise it will throw java.lang.IllegalMonitorStateException exception.
Moreover, we need wait() method for inter-thread communication with notify() and notifyAll().
Therefore It must be present in the synchronized block for the proper and correct communication.

7) What are the advantages of multithreading?

Multithreading programming has the following advantages:
• Multithreading allows an application/program to be always reactive for input, even already
running with some background tasks
• Multithreading allows the faster execution of tasks, as threads execute independently.
• Multithreading provides better utilization of cache memory as threads share the common
memory resources.
• Multithreading reduces the number of the required server as one server can execute multiple
threads at a time.

8) What are the states in the lifecycle of a Thread?

A thread can have one of the following states during its lifetime:
1. New: In this state, a Thread class object is created using a new operator, but the thread is not
alive. Thread doesn't start until we call the start() method.
2. Runnable: In this state, the thread is ready to run after calling the start() method. However, the
thread is not yet selected by the thread scheduler.
3. Running: In this state, the thread scheduler picks the thread from the ready state, and the thread
is running.
4. Waiting/Blocked: In this state, a thread is not running but still alive, or it is waiting for the other
thread to finish.
5. Dead/Terminated: A thread is in terminated or dead state when the run() method exits.
9) What is the difference between preemptive scheduling and time
slicing?
Under preemptive scheduling, the highest priority task executes until it enters the waiting or dead states
or a higher priority task comes into existence. Under time slicing, a task executes for a predefined slice
of time and then reenters the pool of ready tasks. The scheduler then determines which task should
execute next, based on priority and other factors.

10) What is context switching?

In Context switching the state of the process (or thread) is stored so that it can be restored and
execution can be resumed from the same point later. Context switching enables the multiple processes
to share the same CPU.

11) Differentiate between the Thread class and Runnable interface for
creating a Thread?
The Thread can be created by using two ways.
• By extending the Thread class
• By implementing the Runnable interface
However, the primary differences between both the ways are given below:
• By extending the Thread class, we cannot extend any other class, as Java does not allow multiple
inheritances while implementing the Runnable interface; we can also extend other base class(if
required).
• By extending the Thread class, each of thread creates the unique object and associates with it
while implementing the Runnable interface; multiple threads share the same object
• Thread class provides various inbuilt methods such as getPriority(), isAlive and many more while
the Runnable interface provides a single method, i.e., run().

12) What does join() method?

The join() method waits for a thread to die. In other words, it causes the currently running threads to
stop executing until the thread it joins with completes its task. Join method is overloaded in Thread class
in the following ways.
• public void join()throws InterruptedException
• public void join(long milliseconds)throws InterruptedException
More details.

13) Describe the purpose and working of sleep() method.

The sleep() method in java is used to block a thread for a particular time, which means it pause the
execution of a thread for a specific time. There are two methods of doing so.
Syntax:
• public static void sleep(long milliseconds)throws InterruptedException
• public static void sleep(long milliseconds, int nanos)throws InterruptedException
Working of sleep() method
When we call the sleep() method, it pauses the execution of the current thread for the given time and
gives priority to another thread(if available). Moreover, when the waiting time completed then again
previous thread changes its state from waiting to runnable and comes in running state, and the whole
process works so on till the execution doesn't complete.

14) What is the difference between wait() and sleep() method?

wait() sleep()
1) The wait() method is defined in Object class. The sleep() method is defined in Thread class.
2) The wait() method releases the lock. The sleep() method doesn't release the lock.

15) Is it possible to start a thread twice?

No, we cannot restart the thread, as once a thread started and executed, it goes to the Dead state.
Therefore, if we try to start a thread twice, it will give a runtimeException
"java.lang.IllegalThreadStateException". Consider the following example.
1. public class Multithread1 extends Thread
2. {
3. public void run()
4. {
5. try {
6. System.out.println("thread is executing now........");
7. } catch(Exception e) {
8. }
9. }
10. public static void main (String[] args) {
11. Multithread1 m1= new Multithread1();
12. m1.start();
13. m1.start();
14. }
15. }
Output
thread is executing now........
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.start(Thread.java:708)
at Multithread1.main(Multithread1.java:13)
More details.

16) Can we call the run() method instead of start()?

Yes, calling run() method directly is valid, but it will not work as a thread instead it will work as a normal
object. There will not be context-switching between the threads. When we call the start() method, it
internally calls the run() method, which creates a new stack for a thread while directly calling the run()
will not create a new stack.
More details.

17) What about the daemon threads?

The daemon threads are the low priority threads that provide the background support and services to
the user threads. Daemon thread gets automatically terminated by the JVM if the program remains with
the daemon thread only, and all other user threads are ended/died. There are two methods for daemon
thread available in the Thread class:
• public void setDaemon(boolean status): It used to mark the thread daemon thread or a user
thread.
• public boolean isDaemon(): It checks the thread is daemon or not.
More details.

18)Can we make the user thread as daemon thread if the thread is

started?
No, if you do so, it will throw IllegalThreadStateException. Therefore, we can only create a daemon
thread before starting the thread.
1. class Testdaemon1 extends Thread{
2. public void run(){
3. System.out.println("Running thread is daemon...");
4. }
5. public static void main (String[] args) {
6. Testdaemon1 td= new Testdaemon1();
7. td.start();
8. setDaemon(true);// It will throw the exception: td.
9. }
10. }
Output
Running thread is daemon...
Exception in thread "main" java.lang.IllegalThreadStateException
at java.lang.Thread.setDaemon(Thread.java:1359)
at Testdaemon1.main(Testdaemon1.java:8)
More details.

19)What is shutdown hook?

The shutdown hook is a thread that is invoked implicitly before JVM shuts down. So we can use it to
perform clean up the resource or save the state when JVM shuts down normally or abruptly. We can
add shutdown hook by using the following method:
1. public void addShutdownHook(Thread hook){}
2. Runtime r=Runtime.getRuntime();
3. r.addShutdownHook(new MyThread());
Some important points about shutdown hooks are :
• Shutdown hooks initialized but can only be started when JVM shutdown occurred.
• Shutdown hooks are more reliable than the finalizer() because there are very fewer chances that
shutdown hooks not run.
• The shutdown hook can be stopped by calling the halt(int) method of Runtime class.
More details.

20)When should we interrupt a thread?

We should interrupt a thread when we want to break out the sleep or wait state of a thread. We can
interrupt a thread by calling the interrupt() throwing the InterruptedException.
More details.
21) What is the synchronization?
Synchronization is the capability to control the access of multiple threads to any shared resource. It is
used:

1. To prevent thread interference.

2. To prevent consistency problem.
When the multiple threads try to do the same task, there is a possibility of an erroneous result, hence to
remove this issue, Java uses the process of synchronization which allows only one thread to be executed
at a time. Synchronization can be achieved in three ways:
• by the synchronized method
• by synchronized block
• by static synchronization
Syntax for synchronized block
1. synchronized(object reference expression)
2. {
3. //code block
4. }
5.
More details.

22) What is the purpose of the Synchronized block?

The Synchronized block can be used to perform synchronization on any specific resource of the method.
Only one thread at a time can execute on a particular resource, and all other threads which attempt to
enter the synchronized block are blocked.
• Synchronized block is used to lock an object for any shared resource.
• The scope of the synchronized block is limited to the block on which, it is applied. Its scope is
smaller than a method.
More details.

23)Can Java object be locked down for exclusive use by a given

thread?
Yes. You can lock an object by putting it in a "synchronized" block. The locked object is inaccessible to
any thread other than the one that explicitly claimed it.

24) What is static synchronization?

If you make any static method as synchronized, the lock will be on the class not on the object. If we use
the synchronized keyword before a method so it will lock the object (one thread can access an object at
a time) but if we use static synchronized so it will lock a class (one thread can access a class at a time).
More details.

25)What is the difference between notify() and notifyAll()?

The notify() is used to unblock one waiting thread whereas notifyAll() method is used to unblock all the
threads in waiting state.

26)What is the deadlock?

Deadlock is a situation in which every thread is waiting for a resource which is held by some other
waiting thread. In this situation, Neither of the thread executes nor it gets the chance to be executed.
Instead, there exists a universal waiting state among all the threads. Deadlock is a very complicated
situation which can break our code at runtime.
More details.

27) How to detect a deadlock condition? How can it be avoided?

We can detect the deadlock condition by running the code on cmd and collecting the Thread Dump, and
if any deadlock is present in the code, then a message will appear on cmd.
Ways to avoid the deadlock condition in Java:
• Avoid Nested lock: Nested lock is the common reason for deadlock as deadlock occurs when we
provide locks to various threads so we should give one lock to only one thread at some particular
time.
• Avoid unnecessary locks: we must avoid the locks which are not required.
• Using thread join: Thread join helps to wait for a thread until another thread doesn't finish its
execution so we can avoid deadlock by maximum use of join method.

28) What is Thread Scheduler in java?

In Java, when we create the threads, they are supervised with the help of a Thread Scheduler, which is
the part of JVM. Thread scheduler is only responsible for deciding which thread should be executed.
Thread scheduler uses two mechanisms for scheduling the threads: Preemptive and Time Slicing.
Java thread scheduler also works for deciding the following for a thread:
• It selects the priority of the thread.
• It determines the waiting time for a thread
• It checks the Nature of thread

29) Does each thread have its stack in multithreaded programming?

Yes, in multithreaded programming every thread maintains its own or separate stack area in memory
due to which every thread is independent of each other.

30) How is the safety of a thread achieved?

If a method or class object can be used by multiple threads at a time without any race condition, then
the class is thread-safe. Thread safety is used to make a program safe to use in multithreaded
programming. It can be achieved by the following ways:
• Synchronization
• Using Volatile keyword
• Using a lock based mechanism
• Use of atomic wrapper classes

31) What is race-condition?

A Race condition is a problem which occurs in the multithreaded programming when various threads
execute simultaneously accessing a shared resource at the same time. The proper use of
synchronization can avoid the Race condition.

32) What is the volatile keyword in java?

Volatile keyword is used in multithreaded programming to achieve the thread safety, as a change in one
volatile variable is visible to all other threads so one variable can be used by one thread at a time.

33) What do you understand by thread pool?

• Java Thread pool represents a group of worker threads, which are waiting for the task to be
allocated.
• Threads in the thread pool are supervised by the service provider which pulls one thread from the
pool and assign a job to it.
• After completion of the given task, thread again came to the thread pool.
 • The size of the thread pool depends on the total number of threads kept at reserve for execution.
The advantages of the thread pool are :
• Using a thread pool, performance can be enhanced.
• Using a thread pool, better system stability can occur.

Concurrency Interview Questions

34) What are the main components of concurrency API?
Concurrency API can be developed using the class and interfaces of java.util.Concurrent package. There
are the following classes and interfaces in java.util.Concurrent package.
• Executor
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Future
• TimeUnit(Enum)
• CountDownLatch
• CyclicBarrier
• Semaphore
• ThreadFactory
• BlockingQueue
• DelayQueue
• Locks
• Phaser

35) What is the Executor interface in Concurrency API in Java?

The Executor Interface provided by the package java.util.concurrent is the simple interface used to
execute the new task. The execute() method of Executor interface is used to execute some given
command. The syntax of the execute() method is given below.
void execute(Runnable command)
Consider the following example:
1. import java.util.concurrent.Executor;
2. import java.util.concurrent.Executors;
3. import java.util.concurrent.ThreadPoolExecutor;
4. import java.util.concurrent.TimeUnit;
5.
6. public class TestThread {
7. public static void main(final String[] arguments) throws InterruptedException {
8. Executor e = Executors.newCachedThreadPool();
9. e.execute(new Thread());
10. ThreadPoolExecutor pool = (ThreadPoolExecutor)e;
11. pool.shutdown();
12. }
13.
14. static class Thread implements Runnable {
15. public void run() {
16. try {
17. Long duration = (long) (Math.random() * 5);
18. System.out.println("Running Thread!");
19. TimeUnit.SECONDS.sleep(duration);
20. System.out.println("Thread Completed");
21. } catch (InterruptedException ex) {
22. ex.printStackTrace();
 23. }
24. }
25. }
26. }
Output
Running Thread!
Thread Completed

36) What is BlockingQueue?

The java.util.concurrent.BlockingQueue is the subinterface of Queue that supports the operations such
as waiting for the space availability before inserting a new value or waiting for the queue to become
non-empty before retrieving an element from it. Consider the following example.
1.
2. import java.util.Random;
3. import java.util.concurrent.ArrayBlockingQueue;
4. import java.util.concurrent.BlockingQueue;
5.
6. public class TestThread {
7.
8. public static void main(final String[] arguments) throws InterruptedException {
9. BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(10);
10.
11. Insert i = new Insert(queue);
12. Retrieve r = new Retrieve(queue);
13.
14. new Thread(i).start();
15. new Thread(r).start();
16.
17. Thread.sleep(2000);
18. }
19.
20.
21. static class Insert implements Runnable {
22. private BlockingQueue<Integer> queue;
23.
24. public Insert(BlockingQueue queue) {
25. this.queue = queue;
26. }
27.
28. @Override
29. public void run() {
30. Random random = new Random();
31.
32. try {
33. int result = random.nextInt(200);
34. Thread.sleep(1000);
35. queue.put(result);
36. System.out.println("Added: " + result);
37.
38. result = random.nextInt(10);
39. Thread.sleep(1000);
40. queue.put(result);
41. System.out.println("Added: " + result);
 42.
43. result = random.nextInt(50);
44. Thread.sleep(1000);
45. queue.put(result);
46. System.out.println("Added: " + result);
47. } catch (InterruptedException e) {
48. e.printStackTrace();
49. }
50. }
51. }
52.
53. static class Retrieve implements Runnable {
54. private BlockingQueue<Integer> queue;
55.
56. public Retrieve(BlockingQueue queue) {
57. this.queue = queue;
58. }
59.
60. @Override
61. public void run() {
62.
63. try {
64. System.out.println("Removed: " + queue.take());
65. System.out.println("Removed: " + queue.take());
66. System.out.println("Removed: " + queue.take());
67. } catch (InterruptedException e) {
68. e.printStackTrace();
69. }
70. }
71. }
72. }
Output
Added: 96
Removed: 96
Added: 8
Removed: 8
Added: 5
Removed: 5

37) How to implement producer-consumer problem by using

BlockingQueue?
The producer-consumer problem can be solved by using BlockingQueue in the following way.
1.
2. import java.util.concurrent.BlockingQueue;
3. import java.util.concurrent.LinkedBlockingQueue;
4. import java.util.logging.Level;
5. import java.util.logging.Logger;
6. public class ProducerConsumerProblem {
7. public static void main(String args[]){
8. //Creating shared object
9. BlockingQueue sharedQueue = new LinkedBlockingQueue();
10.
11. //Creating Producer and Consumer Thread
12. Thread prod = new Thread(new Producer(sharedQueue));
13. Thread cons = new Thread(new Consumer(sharedQueue));
14.
15. //Starting producer and Consumer thread
16. prod.start();
17. cons.start();
18. }
19.
20. }
21.
22. //Producer Class in java
23. class Producer implements Runnable {
24.
25. private final BlockingQueue sharedQueue;
26.
27. public Producer(BlockingQueue sharedQueue) {
28. this.sharedQueue = sharedQueue;
29. }
30.
31. @Override
32. public void run() {
33. for(int i=0; i<10; i++){
34. try {
35. System.out.println("Produced: " + i);
36. sharedQueue.put(i);
37. } catch (InterruptedException ex) {
38. Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
39. }
40. }
41. }
42.
43. }
44.
45. //Consumer Class in Java
46. class Consumer implements Runnable{
47.
48. private final BlockingQueue sharedQueue;
49.
50. public Consumer (BlockingQueue sharedQueue) {
51. this.sharedQueue = sharedQueue;
52. }
53.
54. @Override
55. public void run() {
56. while(true){
57. try {
58. System.out.println("Consumed: "+ sharedQueue.take());
59. } catch (InterruptedException ex) {
60. Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
61. }
62. }
63. }
 64. }
Output
Produced: 0
Produced: 1
Produced: 2
Produced: 3
Produced: 4
Produced: 5
Produced: 6
Produced: 7
Produced: 8
Produced: 9
Consumed: 0
Consumed: 1
Consumed: 2
Consumed: 3
Consumed: 4
Consumed: 5
Consumed: 6
Consumed: 7
Consumed: 8
Consumed: 9

38) What is the difference between Java Callable interface and

Runnable interface?
The Callable interface and Runnable interface both are used by the classes which wanted to execute
with multiple threads. However, there are two main differences between the both :
• A Callable <V> interface can return a result, whereas the Runnable interface cannot return any
result.
• A Callable <V> interface can throw a checked exception, whereas the Runnable interface cannot
throw checked exception.
• A Callable <V> interface cannot be used before the Java 5 whereas the Runnable interface can be
used.

39) What is the Atomic action in Concurrency in Java?

• The Atomic action is the operation which can be performed in a single unit of a task without any
interference of the other operations.
• The Atomic action cannot be stopped in between the task. Once started it fill stop after the
completion of the task only.
• An increment operation such as a++ does not allow an atomic action.
• All reads and writes operation for the primitive variable (except long and double) are the atomic
operation.
• All reads and writes operation for the volatile variable (including long and double) are the atomic
operation.
• The Atomic methods are available in java.util.Concurrent package.

40) What is lock interface in Concurrency API in Java?

The java.util.concurrent.locks.Lock interface is used as the synchronization mechanism. It works similar
to the synchronized block. There are a few differences between the lock and synchronized block that are
given below.
• Lock interface provides the guarantee of sequence in which the waiting thread will be given the
 access, whereas the synchronized block doesn't guarantee it.
• Lock interface provides the option of timeout if the lock is not granted whereas the synchronized
block doesn't provide that.
• The methods of Lock interface, i.e., Lock() and Unlock() can be called in different methods
whereas single synchronized block must be fully contained in a single method.

41) Explain the ExecutorService Interface.

The ExecutorService Interface is the subinterface of Executor interface and adds the features to manage
the lifecycle. Consider the following example.
1.
2. import java.util.concurrent.ExecutorService;
3. import java.util.concurrent.Executors;
4. import java.util.concurrent.TimeUnit;
5.
6. public class TestThread {
7. public static void main(final String[] arguments) throws InterruptedException {
8. ExecutorService e = Executors.newSingleThreadExecutor();
9.
10. try {
11. e.submit(new Thread());
12. System.out.println("Shutdown executor");
13. e.shutdown();
14. e.awaitTermination(5, TimeUnit.SECONDS);
15. } catch (InterruptedException ex) {
16. System.err.println("tasks interrupted");
17. } finally {
18.
19. if (!e.isTerminated()) {
20. System.err.println("cancel non-finished tasks");
21. }
22. e.shutdownNow();
23. System.out.println("shutdown finished");
24. }
25. }
26.
27. static class Task implements Runnable {
28.
29. public void run() {
30.
31. try {
32. Long duration = (long) (Math.random() * 20);
33. System.out.println("Running Task!");
34. TimeUnit.SECONDS.sleep(duration);
35. } catch (InterruptedException ex) {
36. ex.printStackTrace();
37. }
38. }
39. }
40. }
Output
Shutdown executor
shutdown finished
42) What is the difference between Synchronous programming and
Asynchronous programming regarding a thread?
Synchronous programming: In Synchronous programming model, a thread is assigned to complete a
task and hence thread started working on it, and it is only available for other tasks once it will end the
assigned task.
Asynchronous Programming: In Asynchronous programming, one job can be completed by multiple
threads and hence it provides maximum usability of the various threads.

43) What do you understand by Callable and Future in Java?

Java Callable interface: In Java5 callable interface was provided by the package java.util.concurrent. It is
similar to the Runnable interface but it can return a result, and it can throw an Exception. It also
provides a run() method for execution of a thread. Java Callable can return any object as it uses Generic.
Syntax:
public interface Callable<V>
Java Future interface: Java Future interface gives the result of a concurrent process. The Callable
interface returns the object of java.util.concurrent.Future.
Java Future provides following methods for implementation.
• cancel(boolean mayInterruptIfRunning): It is used to cancel the execution of the assigned task.
• get(): It waits for the time if execution not completed and then retrieved the result.
• isCancelled(): It returns the Boolean value as it returns true if the task was canceled before the
completion.
• isDone(): It returns true if the job is completed successfully else returns false.

44. What is the difference between ScheduledExecutorService and

ExecutorService interface?
ExecutorServcie and ScheduledExecutorService both are the interfaces of java.util.Concurrent package
but scheduledExecutorService provides some additional methods to execute the Runnable and Callable
tasks with the delay or every fixed time period.
45) Define FutureTask class in Java?
Java FutureTask class provides a base implementation of the Future interface. The result can only be
obtained if the execution of one task is completed, and if the computation is not achieved then get
method will be blocked. If the execution is completed, then it cannot be re-started and can't be
canceled.
Syntax
public class FutureTask<V> extends Object implements RunnableFuture<V>
34 Java Collections Interview Questions
In Java, collection interview questions are most asked by the interviewers. Here is the list of the most
asked collections interview questions with answers.

1) What is the Collection framework in Java?

Collection Framework is a combination of classes and interface, which is used to store and manipulate
the data in the form of objects. It provides various classes such as ArrayList, Vector, Stack, and HashSet,
etc. and interfaces such as List, Queue, Set, etc. for this purpose.

2) What are the main differences between array and collection?

Array and Collection are somewhat similar regarding storing the references of objects and manipulating
the data, but they differ in many ways. The main differences between the array and Collection are
defined below:
• Arrays are always of fixed size, i.e., a user can not increase or decrease the length of the array
 according to their requirement or at runtime, but In Collection, size can be changed dynamically as
per need.
• Arrays can only store homogeneous or similar type objects, but in Collection, heterogeneous
objects can be stored.
• Arrays cannot provide the ?ready-made? methods for user requirements as sorting, searching, etc.
but Collection includes readymade methods to use.

3) Explain various interfaces used in Collection framework?

Collection framework implements various interfaces, Collection interface and Map interface
(java.util.Map) are the mainly used interfaces of Java Collection Framework. List of interfaces of
Collection Framework is given below:

1. Collection interface: Collection (java.util.Collection) is the primary interface, and every collection
must implement this interface.
Syntax:
1. public interface Collection<E>extends Iterable
Where <E> represents that this interface is of Generic type
2. List interface: List interface extends the Collection interface, and it is an ordered collection of objects.
It contains duplicate elements. It also allows random access of elements.
Syntax:
1. public interface List<E> extends Collection<E>
3. Set interface: Set (java.util.Set) interface is a collection which cannot contain duplicate elements. It
can only include inherited methods of Collection interface
Syntax:
1. public interface Set<E> extends Collection<E>
Queue interface: Queue (java.util.Queue) interface defines queue data structure, which stores the
elements in the form FIFO (first in first out).
Syntax:
1. public interface Queue<E> extends Collection<E>
4. Dequeue interface: it is a double-ended-queue. It allows the insertion and removal of elements from
both ends. It implants the properties of both Stack and queue so it can perform LIFO (Last in first out)
stack and FIFO (first in first out) queue, operations.
Syntax:
1. public interface Dequeue<E> extends Queue<E>
5. Map interface: A Map (java.util.Map) represents a key, value pair storage of elements. Map interface
does not implement the Collection interface. It can only contain a unique key but can have duplicate
elements. There are two interfaces which implement Map in java that are Map interface and Sorted
Map.

4) What is the difference between ArrayList and Vector?

No. ArrayList Vector
1) ArrayList is not synchronized. Vector is synchronized.
2) ArrayList is not a legacy class. Vector is a legacy class.
3) ArrayList increases its size by 50% of the Vector increases its size by doubling the array
array size. size.
4) ArrayList is not ?thread-safe? as it is not Vector list is ?thread-safe? as it?s every method is
synchronized. synchronized.

5) What is the difference between ArrayList and LinkedList?

No. ArrayList LinkedList
1) ArrayList uses a dynamic array. LinkedList uses a doubly linked list.
2) ArrayList is not efficient for LinkedList is efficient for manipulation.
manipulation because too much is
required.
3) ArrayList is better to store and fetch LinkedList is better to manipulate data.
data.
4) ArrayList provides random access. LinkedList does not provide random access.
5) ArrayList takes less memory overhead LinkedList takes more memory overhead, as it stores
as it stores only object the object as well as the address of that object.

6) What is the difference between Iterator and ListIterator?

Iterator traverses the elements in the forward direction only whereas ListIterator traverses the elements
into forward and backward direction.
No. Iterator ListIterator
1) The Iterator traverses the elements in the ListIterator traverses the elements in backward
forward direction only. and forward directions both.
2) The Iterator can be used in List, Set, and ListIterator can be used in List only.
Queue.
3) The Iterator can only perform remove ListIterator can perform ?add,? ?remove,? and ?
operation while traversing the collection. set? operation while traversing the collection.

7) What is the difference between Iterator and Enumeration?

No. Iterator Enumeration
1) The Iterator can traverse legacy and non- Enumeration can traverse only legacy
legacy elements. elements.
2) The Iterator is fail-fast. Enumeration is not fail-fast.
3) The Iterator is slower than Enumeration. Enumeration is faster than Iterator.
4) The Iterator can perform remove operation The Enumeration can perform only traverse
while traversing the collection. operation on the collection.

8) What is the difference between List and Set?

The List and Set both extend the collection interface. However, there are some differences between the
both which are listed below.
• The List can contain duplicate elements whereas Set includes unique items.
• The List is an ordered collection which maintains the insertion order whereas Set is an unordered
collection which does not preserve the insertion order.
• The List interface contains a single legacy class which is Vector class whereas Set interface does
not have any legacy class.
• The List interface can allow n number of null values whereas Set interface only allows a single null
value.

9) What is the difference between HashSet and TreeSet?

The HashSet and TreeSet, both classes, implement Set interface. The differences between the both are
listed below.
 • HashSet maintains no order whereas TreeSet maintains ascending order.
• HashSet impended by hash table whereas TreeSet implemented by a Tree structure.
• HashSet performs faster than TreeSet.
• HashSet is backed by HashMap whereas TreeSet is backed by TreeMap.

10) What is the difference between Set and Map?

The differences between the Set and Map are given below.
• Set contains values only whereas Map contains key and values both.
• Set contains unique values whereas Map can contain unique Keys with duplicate values.
• Set holds a single number of null value whereas Map can include a single null key with n number
of null values.

11) What is the difference between HashSet and HashMap?

The differences between the HashSet and HashMap are listed below.
• HashSet contains only values whereas HashMap includes the entry (key, value). HashSet can be
iterated, but HashMap needs to convert into Set to be iterated.
• HashSet implements Set interface whereas HashMap implements the Map interface
• HashSet cannot have any duplicate value whereas HashMap can contain duplicate values with
unique keys.
• HashSet contains the only single number of null value whereas HashMap can hold a single null key
with n number of null values.

12) What is the difference between HashMap and TreeMap?

The differences between the HashMap and TreeMap are given below.
• HashMap maintains no order, but TreeMap maintains ascending order.
• HashMap is implemented by hash table whereas TreeMap is implemented by a Tree structure.
• HashMap can be sorted by Key or value whereas TreeMap can be sorted by Key.
• HashMap may contain a null key with multiple null values whereas TreeMap cannot hold a null key
but can have multiple null values.

13) What is the difference between HashMap and Hashtable?

No. HashMap Hashtable
1) HashMap is not synchronized. Hashtable is synchronized.
2) HashMap can contain one null key and multiple Hashtable cannot contain any null key or null
null values. value.
3) HashMap is not ?thread-safe,? so it is useful Hashtable is thread-safe, and it can be
for non-threaded applications. shared between various threads.
4) 4) HashMap inherits the AbstractMap class Hashtable inherits the Dictionary class.

14) What is the difference between Collection and Collections?

The differences between the Collection and Collections are given below.
• The Collection is an interface whereas Collections is a class.
• The Collection interface provides the standard functionality of data structure to List, Set, and
Queue. However, Collections class is to sort and synchronize the collection elements.
• The Collection interface provides the methods that can be used for data structure whereas
Collections class provides the static methods which can be used for various operation on a
collection.
15) What is the difference between Comparable and Comparator?
No. Comparable Comparator
1) Comparable provides only one sort of sequence. The Comparator provides multiple sorts
of sequences.
2) It provides one method named compareTo(). It provides one method named
compare().
3) It is found in java.lang package. It is located in java.util package.
4) If we implement the Comparable interface, The The actual class is not changed.
actual class is modified.

16) What do you understand by BlockingQueue?

BlockingQueue is an interface which extends the Queue interface. It provides concurrency in the
operations like retrieval, insertion, deletion. While retrieval of any element, it waits for the queue to be
non-empty. While storing the elements, it waits for the available space. BlockingQueue cannot contain
null elements, and implementation of BlockingQueue is thread-safe.
Syntax:
1. public interface BlockingQueue<E> extends Queue <E>

17) What is the advantage of Properties file?

If you change the value in the properties file, you don't need to recompile the java class. So, it makes the
application easy to manage. It is used to store information which is to be changed frequently. Consider
the following example.
1. import java.util.*;
2. import java.io.*;
3. public class Test {
4. public static void main(String[] args)throws Exception{
5. FileReader reader=new FileReader("db.properties");
6.
7. Properties p=new Properties();
8. p.load(reader);
9.
10. System.out.println(p.getProperty("user"));
11. System.out.println(p.getProperty("password"));
12. }
13. }
Output
system
oracle

18) What does the hashCode() method?

The hashCode() method returns a hash code value (an integer number).
The hashCode() method returns the same integer number if two keys (by calling equals() method) are
identical.
However, it is possible that two hash code numbers can have different or the same keys.
If two objects do not produce an equal result by using the equals() method, then the hashcode() method
will provide the different integer result for both the objects.

19) Why we override equals() method?

The equals method is used to check whether two objects are the same or not. It needs to be overridden
if we want to check the objects based on the property.
For example, Employee is a class that has 3 data members: id, name, and salary. However, we want to
check the equality of employee object by the salary. Then, we need to override the equals() method.

20) How to synchronize List, Set and Map elements?

Yes, Collections class provides methods to make List, Set or Map elements as synchronized:
public static List synchronizedList(List l){}
public static Set synchronizedSet(Set s){}
public static SortedSet synchronizedSortedSet(SortedSet s){}
public static Map synchronizedMap(Map m){}
public static SortedMap synchronizedSortedMap(SortedMap m){}

21) What is the advantage of the generic collection?

There are three main advantages of using the generic collection.
• If we use the generic class, we don't need typecasting.
• It is type-safe and checked at compile time.
• Generic confirms the stability of the code by making it bug detectable at compile time.

22) What is hash-collision in Hashtable and how it is handled in Java?

Two different keys with the same hash value are known as hash-collision. Two separate entries will be
kept in a single hash bucket to avoid the collision. There are two ways to avoid hash-collision.
• Separate Chaining
• Open Addressing

23) What is the Dictionary class?

The Dictionary class provides the capability to store key-value pairs.

24) What is the default size of load factor in hashing based collection?
The default size of load factor is 0.75. The default capacity is computed as initial capacity * load factor.
For example, 16 * 0.75 = 12. So, 12 is the default capacity of Map.

25) What do you understand by fail-fast?

The Iterator in java which immediately throws ConcurrentmodificationException, if any structural
modification occurs in, is called as a Fail-fast iterator. Fail-fats iterator does not require any extra space
in memory.

26) What is the difference between Array and ArrayList?

The main differences between the Array and ArrayList are given below.
SN Array ArrayList
1 The Array is of fixed size, means we cannot ArrayList is not of the fixed size we can change
resize the array as per need. the size dynamically.
2 Arrays are of the static type. ArrayList is of dynamic size.
3 Arrays can store primitive data types as well ArrayList cannot store the primitive data types
as objects. it can only store the objects.

27) What is the difference between the length of an Array and size of
ArrayList?
The length of an array can be obtained using the property of length whereas ArrayList does not support
length property, but we can use size() method to get the number of objects in the list.
Finding the length of the array
1. Int [] array = new int[4];
2. System.out.println("The size of the array is " + array.length);
3.
Finding the size of the ArrayList
1. ArrayList<String> list=new ArrayList<String>();
2. list.add("ankit");
3. list.add("nippun");
4. System.out.println(list.size());
5.

28) How to convert ArrayList to Array and Array to ArrayList?

We can convert an Array to ArrayList by using the asList() method of Arrays class. asList() method is the
static method of Arrays class and accepts the List object. Consider the following syntax:
1. Arrays.asList(item)
We can convert an ArrayList to Array using toArray() method of the ArrayList class. Consider the
following syntax to convert the ArrayList to the List object.
1. List_object.toArray(new String[List_object.size()])

29) How to make Java ArrayList Read-Only?

We can obtain java ArrayList Read-only by calling the Collections.unmodifiableCollection() method.
When we define an ArrayList as Read-only then we cannot perform any modification in the collection
through add(), remove() or set() method.

30) How to remove duplicates from ArrayList?

There are two ways to remove duplicates from the ArrayList.
• Using HashSet: By using HashSet we can remove the duplicate element from the ArrayList, but it
will not then preserve the insertion order.
• Using LinkedHashSet: We can also maintain the insertion order by using LinkedHashSet instead of
HashSet.
The Process to remove duplicate elements from ArrayList using the LinkedHashSet:
• Copy all the elements of ArrayList to LinkedHashSet.
• Empty the ArrayList using clear() method, which will remove all the elements from the list.
• Now copy all the elements of LinkedHashset to ArrayList.

31) How to reverse ArrayList?

To reverse an ArrayList, we can use reverse() method of Collections class. Consider the following
example.
1. import java.util.ArrayList;
2. import java.util.Collection;
3. import java.util.Collections;
4. import java.util.Iterator;
5. import java.util.List;
6. public class ReverseArrayList {
7. public static void main(String[] args) {
8. List list = new ArrayList<>();
9. list.add(10);
10. list.add(50);
 11. list.add(30);
12. Iterator i = list.iterator();
13. System.out.println("printing the list....");
14. while(i.hasNext())
15. {
16. System.out.println(i.next());
17. }
18. Iterator i2 = list.iterator();
19. Collections.reverse(list);
20. System.out.println("printing list in reverse order....");
21. while(i2.hasNext())
22. {
23. System.out.println(i2.next());
24. }
25. }
26. }
Output
printing the list....
10
50
30
printing list in reverse order....
30
50
10

32) How to sort ArrayList in descending order?

To sort the ArrayList in descending order, we can use the reverseOrder method of Collections class.
Consider the following example.
1. import java.util.ArrayList;
2. import java.util.Collection;
3. import java.util.Collections;
4. import java.util.Comparator;
5. import java.util.Iterator;
6. import java.util.List;
7.
8. public class ReverseArrayList {
9. public static void main(String[] args) {
10. List list = new ArrayList<>();
11. list.add(10);
12. list.add(50);
13. list.add(30);
14. list.add(60);
15. list.add(20);
16. list.add(90);
17.
18. Iterator i = list.iterator();
19. System.out.println("printing the list....");
20. while(i.hasNext())
21. {
22. System.out.println(i.next());
23. }
24.
 25. Comparator cmp = Collections.reverseOrder();
26. Collections.sort(list,cmp);
27. System.out.println("printing list in descending order....");
28. Iterator i2 = list.iterator();
29. while(i2.hasNext())
30. {
31. System.out.println(i2.next());
32. }
33.
34. }
35. }
Output
printing the list....
10
50
30
60
20
90
printing list in descending order....
90
60
50
30
20
10

33) How to synchronize ArrayList?

We can synchronize ArrayList in two ways.
• Using Collections.synchronizedList() method
• Using CopyOnWriteArrayList<T>

34) When to use ArrayList and LinkedList?

LinkedLists are better to use for the update operations whereas ArrayLists are better to use for the
search operations.

From <https://www.javatpoint.com/java-collections-interview-questions>

From <https://www.javatpoint.com/java-multithreading-interview-questions>
Java Interview Questions from simplilern
Monday, February 13, 2023 11:23 PM

Java Interview Questions for Freshers

So let’s get started with the first set of basic core Java technical interview questions which is primarly
useful for freshers.
1. What are the differences between C++ and Java?
• Concept.
C++ is not platform-independent; the principle behind C++ programming is “write once, compile
anywhere.”
In contrast, because the byte code generated by the Java compiler is platform-independent, it can run
on any machine, Java programs are written once and run everywhere.
Also Read: Learn C++ Programming
• Languages Compatibility.
C++ is a programming language that is based on the C programming language. Most other high-level
languages are compatible with C++.
Most of the languages of Java are incompatible. Java is comparable to those of C and C++.
• Interaction with the library.
It can access the native system libraries directly in C++. As a result, it’s better for programming at the
system level.
Java’s native libraries do not provide direct call support. You can use Java Native Interface or access the
libraries.
• Characteristics.
C++ distinguishes itself by having features that are similar to procedural and object-oriented languages.
The characteristic that sets Java apart is automatic garbage collection. Java doesn’t support destructors
at the moment.
• The semantics of the type.
Primitive and object types in C++ have the same kind of semantics. The primitive and object and classes
of Java, on the other hand, are not consistent.
• In the context of Compiler and Interpreter.
Java refers to a compiled and interpreted language. In contrast, C++ is only a compiled language.
In Java, the source code is the compiled output is a platform-independent byte code.
In C++, the source program is compiled into an object code that is further executed to produce an
output.
2. List the features of the Java Programming language?
A few of the significant features of Java Programming Language are:
Easy: Java is a language that is considered easy to learn. One fundamental concept of OOP Java has a
catch to understand.
Secured Feature: Java has a secured feature that helps develop a virus-free and tamper-free system for
the users.
OOP: OOP stands for Object-Oriented Programming language. OOP signifies that, in Java, everything is
considered an object.
Independent Platform: Java is not compiled into a platform-specific machine; instead, it is compiled into
platform-independent bytecode. This code is interpreted by the Virtual Machine on which the platform
runs.
Get the Must-Have Skills of a Web Developer
Caltech Coding BootcampExplore Program

3. What do you get in the Java download file? How do they differ from
one another?
We get two major things along with the Java Download file.
JDK - Java Development Kit
JRE - Java Runtime Environment
JDK JRE
Abbreviation for JavaDevelopment Kit Abbreviation for Java Runtime Environment
JDK is a dedicated kit for solely software JRE is a set of software and library designed for executing
development Java Programs
Unlike JVM, JDK is Platform Dependent Unlike JVM, JRE is also Platform Dependent
JDK package is a set of tools for debugging JRE Package is one that only supports files and libraries for
and Developing a runtime environment
JDK package will be provided with an JRE Package does not get an installer but has only a
installer file runtime environment

4. What is a ClassLoader?
A classloader in Java is a subsystem of Java Virtual Machine, dedicated to loading class files when a
program is executed; ClassLoader is the first to load the executable file.
Java has Bootstrap, Extension, and Application classloaders.
Also Read: What is Bootstrap and How to Embed Bootstrap into Angular?
5. What are the Memory Allocations available in JavaJava?
Java has five significant types of memory allocations.
• Class Memory
• Heap Memory
• Stack Memory
• Program Counter-Memory
• Native Method Stack Memory
6. What are the differences between Heap and Stack Memory in Java?
Stack memory in data structures is the amount of memory allocated to each individual programme. It is
a fixed memory space. Heap memory, in contrast, is the portion that was not assigned to the Java code
but will be available for use by the Java code when it is required, which is generally during the program's
runtime.
7. Will the program run if we write static public void main?
Yes, the program will successfully execute if written so. Because, in Java, there is no specific rule for the
order of specifiers
8. What is the default value stored in Local Variables?
Neither the Local Variables nor any primitives and Object references have any default value stored in
them.
9. Explain the expected output of the following code segment?
public class Simplilearn
{
public static void main (String args[])
{
System.out.println(100 + 100 +“Simplilearn");
System.out.println(“E-Learning Company" + 100 + 100);
}
}
The answers for the two print statements are as follows.
• 200Simplilearn
 • E-Learning Company100100
Here's How to Land a Top Software Developer Job
Full Stack Development-MEANExplore Program

10. What is an Association?

An Association can be defined as a relationship that has no ownership over another. For example, a
person can be associated with multiple banks, and a bank can be related to various people, but no one
can own the other.
11. What do you mean by aggregation?
The term aggregation refers to the relationship between two classes best described as a “whole/part”
and “has-a” relationship. This kind is the most specialized version of an association relationship. It
contains the reference to another class and is said to have ownership of that class.
12. Define Copy Constructor in Java
A Copy Constructor in Java is a constructor that initializes an object through another object of the same
class.
13. What is a Marker Interface?
An empty interface in Java is referred to as a Marker interface. Serializable and Cloneable are some
famous examples of Marker Interface.
14. What is Object Cloning?
An ability to recreate an object entirely similar to an existing object is known as Object Cloning in Java.
Java provides a clone() method to clone a current object offering the same functionality as the original
object.
15. Can Java be said to be the complete object-oriented programming
language
No, Java cannot be treated as a complete object-oriented programming language.
16. What is an object-oriented paradigm?
A Paradigm that is based on the concepts of “Objects.” It contains data and code. Data that is in the
form of fields, and regulation, that is in the form of procedures. The exciting feature of this paradigm is
that the object’s procedures can access and often modify the data fields themselves.
17. Define Wrapper Classes in Java.
In Java, when you declare primitive datatypes, then Wrapper classes are responsible for converting
them into objects(Reference types).
18. What is a singleton class in Java? And How to implement a
singleton class?
A class that can possess only one object at a time is called a singleton class. To implement a singleton
class given steps are to be followed:
1. Make sure that the class has only one object
2. Give global access to that object
Develop Your Career with Purdue Coding Bootcamp
Free Webinar | 21 February, Tuesday | 4:30 PM ISTRegister Now

19. Define package in Java.

The package is a collective bundle of classes and interfaces and the necessary libraries and JAR files. The
use of packages helps in code reusability.
20. Can you implement pointers in a Java Program?
Java Virtual Machine takes care of memory management implicitly. Java's primary motto was to keep
programming simple. So, accessing memory directly through pointers is not a recommended action.
Hence, pointers are eliminated in Java.
21. Differentiate between instance and local variables.
For instance, variables are declared inside a class, and the scope of variables in javascript is limited to
only a specific object.
A local variable can be anywhere inside a method or a specific block of code. Also, the scope is limited to
the code segment where the variable is declared.
22. Explain Java String Pool.
A collection of strings in Java's Heap memory is referred to as Java String Pool. In case you try to create a
new string object, JVM first checks for the presence of the object in the pool. If available, the same
object reference is shared with the variable, else a new object is created.
23. What is an Exception?
An Exception handling in Java is considered an unexpected event that can disrupt the program's normal
flow. These events can be fixed through the process of Exception Handling.
24. What is the final keyword in Java?
The term final is a predefined word in Java that is used while declaring values to variables. When a value
is declared using the final keyword, then the variable's value remains constant throughout the
program's execution.
25. What happens when the main() isn't declared as static?
When the main method is not declared as static, then the program may be compiled correctly but ends
up with a severe ambiguity and throws a run time error that reads "NoSuchMethodError."
26. Why is Java a platform independent language?
One of the most well-known and widely used programming languages is Java. It is a programming
language that is independent of platforms. Java doesn't demand that the complete programme be
rewritten for every possible platform. The Java Virtual Machine and Java Bytecode are used to support
platform independence. Any JVM operating system can run this platform-neutral byte code. The
application is run after JVM translates the byte code into machine code. Because Java programmes can
operate on numerous systems without having to be individually rewritten for each platform, the
language is referred to as "Write Once, Run Anywhere" (WORA).
27. Why is the main method static in Java?
Java's main() function is static by default, allowing the compiler to call it either before or after creating a
class object. The main () function is where the compiler begins programme execution in every Java
programme. Thus, the main () method needs to be called by the compiler. If the main () method is
permitted to be non-static, the JVM must instantiate its class when calling the function.
28. What part of memory - Stack or Heap - is cleaned in the garbage
collection process?
On Heap memory, garbage collection is employed to release the memory used by objects with no
references. Every object created in the Heap space has access to the entire application and may be
referred to from anywhere.
29. What is the difference between the program and the process?
A programme is a non-active entity that includes the collection of codes necessary to carry out a specific
operation. When a programme is run, an active instance of the programme called a process is launched.
A process is begun by a programme once it has been run. The process carries out the program's
specified instructions.
30. What are the differences between constructor and method of a
class in Java?
Initializing the state of the object is done by constructors. A function Object () { [native code] }, like
methods, contains a group of statements (or instructions) that are carried out when an object is created.
A method is a group of statements that work together to complete a certain task and return the
outcome to the caller. A method has the option of working without returning anything.
31. Which among String or String Buffer should be preferred when
there are a lot of updates required to be done in the data?
Because StringBuilder is quicker than StringBuffer, it is advised to utilize it wherever possible. However,
StringBuffer objects are the best choice if thread safety is required.
32. What happens if the static modifier is not included in the main
method signature in Java?
The main function is called by the JVM even before the objects are created, thus even if the code
correctly compiles, there will still be an error at runtime.
33. Can we make the main() thread a daemon thread?
This technique designates whether the active thread is a user thread or a daemon thread. For instance,
tU.setDaemon(true) would convert a user thread named tU into a daemon thread. On the other side,
executing tD.setDaemon(false) would convert a Daemon thread, tD, into a user thread.
34. What happens if there are multiple main methods inside one class
in Java?
There is no limit to the number of major approaches you can use. Overloading is the ability to have main
methods with different signatures than main (String []), and the JVM will disregard those main methods.
35. How does an exception propagate in the code?
In the event that an exception is not caught, it is initially thrown from the top of the stack and then
moves down the call stack to the preceding method. The runtime system looks for a way to handle an
exception that a method throws. The ordered list of methods that were called to get to the method
where the error occurred is the collection of potential "somethings" that can be used to manage the
exception. The call stack is the list of methods, and exception propagation is the search technique.
36. How do exceptions affect the program if it doesn't handle them?
If you don't deal with an exception once it occurs, the programme will end abruptly and the code after
the line where the exception occurred won't run.
37. Is it mandatory for a catch block to be followed after a try block?
Each attempt block does not necessarily have to be followed by a catch block. Either a catch block or a
final block ought to come after it. Additionally, any exceptions that are expected to be thrown should be
mentioned in the method's throws clause.
38. Can you call a constructor of a class inside another constructor?
Yes, a class may include any number of constructors, and each function Object () {[native code] } may
call the others using the this() function Object() { [native code] } call function [please do not mix the
this() function Object() { [native code] } call function with this keyword]. The constructor's first line
should be either this () or this(args). Overloading of constructors is what this is called.
39. Contiguous memory locations are usually used for storing actual
values in an array but not in ArrayList. Explain.
Primitive data types like int, float, and others are typically present in an array. In such circumstances, the
array immediately saves these elements at contiguous memory regions. While an ArrayList does not
contain primitive data types. Instead of the actual object, an ArrayList includes the references to the
objects' many locations in memory. The objects are not kept in consecutive memory regions because of
this.
40. Why does the java array index start with 0?
The distance from the array's beginning is just an offset. There is no distance because the first element is
at the beginning of the array. Consequently, the offset is 0.
41. Why is the remove method faster in the linked list than in an
array?
Because there is no background scaling of an array, insertion, addition, and removal operations are
quicker with a LinkedList. Only references in adjacent items need to update when a new item is added in
the middle of the list.
42. How many overloaded add() and addAll() methods are available in
the List interface? Describe the need and uses.
List is an interface in the Java Collections Framework. The add() and addAll() methods are the main
methods at the List interface. The add() method is used to add an element to the list, while the addAll()
method is used to add a collection of elements to the list.
The List interface contains two overloaded versions of the add() method:
The first add() method accepts a single argument of type E, the element to be added to the list.
The second add() method accepts a variable number of arguments of type E, which are the elements to
be added to the list.
The List interface also contains two overloaded versions of the addAll() method:
The first addAll() method accepts a single argument of type Collection<? Extends E>, which is the
collection of elements to be added to the list.
The second addAll() method accepts a variable number of arguments of type E, which are the elements
to be added to the list.
43. How does the size of ArrayList grow dynamically? And also state
how it is implemented internally?
A resizable array implementation in Java is called ArrayList. Dynamically expanding array lists make it
possible to add new elements at any time. The underlying data structure of the ArrayList is an array of
the Object class. The ArrayList class in Java has three constructors. There are available readObject and
writeObject methods specific to it. The Object Array in an ArrayList is temporary. There are
implemented and Serialization-capable versions of RandomAccess, Cloneable, and java.io (that are
Marker Interface in Java).
44. Although inheritance is a popular OOPs concept, it is less
advantageous than composition. Explain.
A class's testability is improved through composition over inheritance. If a class is comprised of another
class, it is simple to create a mock object to simulate the combined class for testing purposes. This
privilege is not given by inheritance. Even while Composition and Inheritance both let you reuse code,
Inheritance has the drawback of breaking encapsulation. If the function of the subclass depends on the
superclass's action, it suddenly becomes vulnerable. Sub-class functionality may be broken without any
alteration on the part of the super-class when its behaviour changes.
45. What are Composition and Aggregation? State the difference.
Aggregation (HAS-A) and composition are its two forms (Belongs-to). In contrast to composition, which
has a significant correlation, the aggregation has a very modest association. Aggregation can be thought
of as a more confined version of the composition. Since all compositions are aggregates but not all
aggregates are compositions, aggregate can be thought of as the superset of composition.
46. How is the creation of a String using new() different from that of a
literal?
The new () operator always produces a new object in heap memory when creating a String object. The
String pool may return an existing object if we build an object using the String literal syntax, such as
"Baeldung," on the other hand.
47. How is the ‘new' operator different from the ‘newInstance()'
operator in java?
Both the new operator and the newInstance() method are used to create objects in Java. If we already
know the kind of object to create, we can use the new operator; however, if the type of object to create
is supplied to us at runtime, we must use the newInstance() function.
48. Is exceeding the memory limit possible in a program despite
having a garbage collector?
Yes, even with a garbage collector in place, the programme could still run out of memory. Garbage
collection aids in identifying and removing programme objects that are no longer needed in order to
release the resources they use. When an object in a programme cannot be reached, trash collection is
executed with respect to that object. If there is not enough memory available to create new objects, a
garbage collector is used to free up memory for things that have been removed from the scope. When
the amount of memory released is insufficient for the creation of new objects, the program's memory
limit is exceeded.
49. Why is synchronization necessary? Explain with the help of a
relevant example.
Multiple threads trying to access the same resources in a multi-threaded software may frequently result
in unexpected and incorrect outcomes. Therefore, it must be ensured through some form of
synchronization that only one thread can access the resource at any given time. Java offers a method for
setting up threads and synchronizing their operations with the aid of synchronized blocks. The
synchronized keyword in Java is used to identify synchronized blocks. In Java, a synchronized block is
one that is tied to an object. Only one thread can be running at a time inside synchronized blocks since
they are all synchronized on the same object. Until the thread inside the synchronized block exits the
block, all other threads trying to enter the block are blocked.
50. Define System.out.println().
System.out.println() in Java outputs the argument that was supplied to it. On the monitor, the println()
method displays the findings. An objectname is typically used to call a method.
FREE Java Certification Training
Learn A-Z of Java like never beforeEnroll Now

51. Can you explain the Java thread lifecycle?

A thread can be in any of the following states in Java. These are the states:
• New: A new thread is always in the new state when it is first formed. The function hasn't been run
yet, thus it hasn't started to execute for a thread in the new state.
• Active: A thread switches from the new state to the active state when it calls the start() method.
The runnable state and the running state are both contained within the active state.
• Blocked or Waiting: A thread is either in the blocked state or the waiting state when it is inactive
for a while (but not indefinitely).
• Timed waiting: When we use the sleep () method on a particular thread, we are actually engaging
in timed waiting. The thread enters the timed wait state using the sleep () function. The thread
awakens when the allotted time has passed and resumes execution where it left off.
• Termination: A thread that has been terminated means it is no longer active in the system. In
other words, the thread is inactive and cannot be revived (made active again after being killed).
52. What could be the tradeoff between the usage of an unordered
array versus the usage of an ordered array?
When opposed to an unordered array, which has a time complexity of O, an ordered array's search
times have a time complexity of O(log n) (n). Due to the need to shift the elements with higher values to
create room for the new member, an ordered array has a temporal complexity of O(n) during the
insertion process. Instead, an unordered array's insertion operation requires a constant O amount of
time (1).
53. Is it possible to import the same class or package twice in Java and
what happens to it during runtime?
The same package or class may be imported more than once. Neither the JVM nor the compiler raise an
objection. Even if you import the same class several times, the JVM will only internally load it once.
54. In case a package has sub packages, will it suffice to import only
the main package? e.g. Does importing of com.myMainPackage.* also
import com.myMainPackage.mySubPackage.*?
Sub-packages won't be imported when a package is imported. When you import a package, all of its
classes and interfaces—with the exception of those from its sub-packages—are imported.
55. Will the final block be executed if the code System.exit(0) is
written at the end of the try block?
The system is established as the last line to be run, after which nothing will happen, therefore both the
catch and finally blocks are essentially ignored.
56. Explain the term “Double Brace Initialisation” in Java?
The outer braces of the double-brace initialization construct an anonymous class that is descended from
the provided class and gives an initializer block for that class (the inner braces).
57. Why is it said that the length() method of String class doesn't
return accurate results?
Since this char [] array is used by the Java String class internally, the length variable cannot be made
public.
58. What are the possible ways of making objects eligible for garbage
collection (GC) in Java?
If a reference variable for an object is removed from the programme while it is running, the object may
be trash collected. They are also referred to as inaccessible objects occasionally. The new operator
returns a reference to an object after dynamically allocating memory for it.
59. In the below Java Program, how many objects are eligible for
garbage collection?
I don't know about the program, but generally, three objects are eligible for garbage collection.
The first object is created when the program is started and is no longer needed when the program ends.
The second object is created when the user inputs their name and is no longer required when the
program ends.
The third object is created when the user inputs their address and is no longer needed when the
program ends.
60. What is the best way to inject dependency? Also, state the reason.
Constructor injection. A class requesting its dependencies through its function Object() { [native code] }
is the most typical instance of dependency injection. Since the client cannot be constructed without the
required dependencies, this guarantees that it is always in a correct state.
61. How we can set the spring bean scope. And what supported
scopes does it have?
There are four ways to set the scope of a Spring bean: singleton, prototype, request, and session.
The singleton scope creates a single instance of a bean, which is shared by all objects that request it.
The prototype scope creates a new instance of a bean for each object that requests it.
The request and session scopes are only available in a web-based context. The request scope creates a
new bean instance for each HTTP request, and the session scope creates a single instance of a bean
shared by all objects in a single HTTP session.
62. What are the different categories of Java Design patterns?
The three categories of Java design patterns are creational, structural, and behavioural design patterns.
63. What is a Memory Leak? Discuss some common causes of it.
A memory leak is the slow degradation of system performance over time brought on by the
fragmentation of a computer's RAM as a result of shoddy application design or programming that fails to
release memory chunks when they are no longer required. These memory leaks frequently result from
session items in excess, insertion into Collection objects without deletion, infinite caches, excessive page
switching on the operating system, listener methods that are not called, and bespoke data structures
that are poorly written.
64. Assume a thread has a lock on it, calling the sleep() method on
that thread will release the lock?
No, the thread might release the locks using notify, notifyAll(), and wait() methods.
65. Write a Java Program to print Fibonacci Series using Recursion.
class FibonacciExample2{
static int n1=0,n2=1,n3=0;
static void printFibonacci(int count){
if(count>0){
n3 = n1 + n2;
n1 = n2;
n2 = n3;
System.out.print(" "+n3);
printFibonacci(count-1);
}
}
public static void main(String args[]){
int count=10;
System.out.print(n1+" "+n2);//printing 0 and 1
printFibonacci(count-2);//n-2 because 2 numbers are already printed
}
}
66. Write a Java program to check if the two strings are anagrams.
import java.util.Arrays;
public class AnagramString {
static void isAnagram(String str1, String str2) {
String s1 = str1.replaceAll("\\s", "");
String s2 = str2.replaceAll("\\s", "");
boolean status = true;
if (s1.length() != s2.length()) {
status = false;
} else {
char[] ArrayS1 = s1.toLowerCase().toCharArray();
char[] ArrayS2 = s2.toLowerCase().toCharArray();
Arrays.sort(ArrayS1);
Arrays.sort(ArrayS2);
status = Arrays.equals(ArrayS1, ArrayS2);
}
if (status) {
System.out.println(s1 + " and " + s2 + " are anagrams");
} else {
System.out.println(s1 + " and " + s2 + " are not anagrams");
}
}
public static void main(String[] args) {
isAnagram("Keep", "Peek");
isAnagram("Mother In Law", "Hitler Woman");
 }
}
Output
Keep and Peek are anagrams
MotherInLaw and HitlerWoman are anagrams
67. Write a Java Program to find the factorial of a given number.
4! = 4*3*2*1 = 24
5! = 5*4*3*2*1 = 120
68. Given an array of non-duplicating numbers from 1 to n where one
number is missing, write an efficient java program to find that missing
number.
Input: arr[] = {1, 2, 4, 6, 3, 7, 8}, N = 8
Output: 5
Explanation: The missing number between 1 to 8 is 5
69. Write a Java Program to check if any number is a magic number or
not. A number is said to be a magic number if after doing the sum of
digits in each step and in turn doing the sum of digits of that sum, the
ultimate result (when there is only one digit left) is 1.
// Java program to check if
// a number is Magic number.
class GFG
{
public static boolean isMagic(int n)
{
int sum = 0;
// Note that the loop continues
// if n is 0 and sum is non-zero.
// It stops when n becomes 0 and
// sum becomes single digit.
while (n > 0 || sum > 9)
{
if (n == 0)
{
n = sum;
sum = 0;
}
sum += n % 10;
n /= 10;
}

// Return true if sum becomes 1.

return (sum == 1);
}
// Driver code
public static void main(String args[])
{
int n = 1234;
if (isMagic(n))
System.out.println("Magic Number");
 else
System.out.println("Not a magic Number");
}
}
class InvalidAgeException extends Exception
{
public InvalidAgeException (String str)
{
// calling the constructor of parent Exception
super(str);
}
}
70. Write a Java program to create and throw custom exceptions.
// class that uses custom exception InvalidAgeException
public class TestCustomException1
{
// method to check the age
static void validate (int age) throws InvalidAgeException{
if(age < 18){
// throw an object of user defined exception
throw new InvalidAgeException("age is not valid to vote");
}
else {
System.out.println("welcome to vote");
}
}
// main method
public static void main(String args[])
{
try
{
// calling the method
validate(13);
}
catch (InvalidAgeException ex)
{
System.out.println("Caught the exception");

// printing the message from InvalidAgeException object

System.out.println("Exception occured: " + ex);
}
System.out.println("rest of the code...");
}
}
71. Write a Java program to rotate arrays 90 degree clockwise by
taking matrices from user input.
public class RotateMatrixClockwise
{
public static void main(String args[])
{
//matrix to rotate
int a[][]= {{1,2,3},{4,5,6},{7,8,9}};
System.out.println("Original Matrix: \n");
//loop for rows
for(int i=0;i<3;i++)
{
//loop for columns
for(int j=0;j<3;j++)
{
//prints the elements of the original matrix
System.out.print(" "+a[i][j]+"\t");
}
System.out.println("\n");
}
System.out.println("Rotate Matrix by 90 Degrees Clockwise: \n");
for(int i=0;i<3;i++)
{
for(int j=2;j>=0;j--)
{
//prints the elements of the rotated matrix
System.out.print(""+a[j][i]+"\t");
}
System.out.println("\n");
}
}
}
72. Write a java program to check if any number given as input is the
sum of 2 prime numbers.
// C program to check if a prime number
// can be expressed as sum of
// two Prime Numbers
#include <stdio.h>
#include <math.h>
#include <stdbool.h>
// Function to check whether a number
// is prime or not
bool isPrime(int n)
{
if (n <= 1)
return false;
for (int i = 2; i <= sqrt(n); i++)
{
if (n % i == 0)
return false;
}
return true;
}
// Function to check if a prime number
// can be expressed as sum of
// two Prime Numbers
bool isPossible(int N)
{
// if the number is prime,
// and number-2 is also prime
 if (isPrime(N) && isPrime(N - 2))
return true;
else
return false;
}
// Driver code
int main()
{
int n = 13;

if (isPossible(n))
printf("%s", "Yes");
else
printf("%s", "No");

return 0;
}
73. Write a Java program for solving the Tower of Hanoi Problem.
// Java recursive program to solve tower of hanoi puzzle
class GFG
{
// Java recursive function to solve tower of hanoi puzzle
static void towerOfHanoi(int n, char from_rod, char to_rod, char aux_rod)
{
if (n == 1)
{
System.out.println("Move disk 1 from rod " + from_rod + " to rod " +to_rod);
return;
}
towerOfHanoi(n-1, from_rod, aux_rod, to_rod);
System.out.println("Move disk " + n + " from rod " + from_rod + " to rod " +to_rod);
towerOfHanoi(n-1, aux_rod, to_rod, from_rod);
}
// Driver method
public static void main(String args[])
{
int n = 4; // Number of disks
towerOfHanoi(n, \'A\', \'C\', \'B\'); // A, B and C are names of rods
}
}
74. Implement Binary Search in Java using recursion.
// Java Program to Illustrate Recursive Binary Search
// Importing required classes
import java.util.*;
// Main class
class GFG {
// Method 1
// Recursive binary search
// Returns index of x if it is present
// in arr[l..r], else return -1
int binarySearch(int arr[], int l, int r, int x)
{
 // Restrict the boundary of right index
// and the left index to prevent
// overflow of indices
if (r >= l && l <= arr.length - 1) {
int mid = l + (r - l) / 2;
// If the element is present
// at the middle itself
if (arr[mid] == x)
return mid;
// If element is smaller than mid, then it can
// only be present in left subarray
if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);

// Else the element can only be present

// in right subarray
return binarySearch(arr, mid + 1, r, x);
}
// We reach here when element is not present in
// array
return -1;
}
// Method 2
// Main driver method
public static void main(String args[])
{
// Creating object of above class
GFG ob = new GFG();
// Custom input array
int arr[] = { 2, 3, 4, 10, 40 };

// Length of array
int n = arr.length;
// Custom element to be checked
// whether present or not
int x = 10;
// Calling above method
int result = ob.binarySearch(arr, 0, n - 1, x);
// Element present
if (result == -1)
// Print statement
System.out.println("Element not present");

// Element not present

else
// Print statement
System.out.println("Element found at index "
+ result);
}
}
75. Is delete, next, main, exit or null keyword in java?
No, these keywords do not exist in Java. Delete, Next, Exit are the operations performed in the Java
program, Main is the predefined method, and Null is the default String type.
With this we are done with the first section that is Basic Java Interview Question, Now, lets move on to
our next section of Intermediate Java Interview Questions.
Java Interview Coding Questions For Intermediate
Now, let's have a look at some of the most asked Java technical interview questions for intermediate
experienced professionals.
76. What is JDK? Mention the variants of JDK?
JDK is an abbreviation for Java Development Kit. It is a combined Package of JRE and Developer tools
used for designing Java Applications and Applets. Oracle has the following variants.
• JDK Standard Edition
• JDK Enterprise Edition
• JDK Micro Edition
77. What is the difference between JDK, JRE, and JVM?
JVM has a Just in Time (JIT) compiler tool that converts all the Java source code into the low-level
compatible machine language. Therefore, it runs faster than the regular application.
JRE has class libraries and other JVM supporting files. But it doesn’t have any tool for java development
such as compiler or debugger.
JDK has tools that are required to write Java Programs and uses JRE to execute them. It has a compiler,
Java application launcher, and an applet viewer.
78. What is a JIT compiler?
JIT compiler refers to Just in Time compiler. It is the simplest way of executing the computer code that
takes in compilation during the execution of a program rather than before performance. It commonly
uses bytecode translation to machine code. It is then executed directly.
79. What are Brief Access Specifiers and Types of Access Specifiers?
Access Specifiers are predefined keywords used to help JVM understand the scope of a variable,
method, and class. We have four access specifiers.
• Public Access Specifier
• Private Access Specifier
• Protected Access Specifier
• Default Access Specifier
80. How many types of constructors are used in Java?
There are two types of constructors in Java.
Parameterized Constructors: Parameterized constructor accepts the parameters with which users can
initialize the instance variables. Users can initialize the class variables dynamically at the time of
instantiating the class.
Default constructors: This type doesn’t accept any parameters; rather, it instantiates the class variables
with their default values. It is used mainly for object creation.
81. Can a constructor return a value?
Yes, A constructor can return a value. It replaces the class's current instance implicitly; you cannot make
a constructor return a value explicitly.
82. Explain ‘this’ keyword in Java.
The term "this" is a particular keyword designated as a reference keyword. The "this" keyword is used to
refer to the current class properties like method, instance, variable, and constructors.
83. Explain ‘super’ keyword in Java.
The term "super" is a particular keyword designated as a reference keyword. The "super" keyword
refers to the immediate parent class object.
84. Explain Method Overloading in Java.
The process of creating multiple method signatures using one method name is called Method
Overloading in Java. Two ways to achieve method overloading are:
 1. Varying the number of arguments
2. Changing the return type of the Method
85. Can we overload a static method?
No, Java does not support the Overloading of a static method. The process would throw an error reading
"static method cannot be referenced."
86. Define Late Binding.
Binding is a process of unifying the method call with the method's code segment. Late binding happens
when the method's code segment is unknown until it is called during the runtime.
New Course: Full Stack Development for Beginners
Learn Git Command, Angular, NodeJS, Maven & MoreEnroll Now

87. Define Dynamic Method Dispatch.

The Dynamic method dispatch is a process where the method call is executed during the runtime. A
reference variable is used to call the super-class. This process is also known as Run-Time
Polymorphism.
88. Why is the delete function faster in the linked list than an array?
Delete Function is faster in linked lists in Java as the user needs to make a minor update to the pointer
value so that the node can point to the next successor in the list
89. Give a briefing on the life cycle of a thread.
The life cycle of a thread includes five stages, as mentioned below.
1. New Born State
2. Runnable State
3. Running State
4. Blocked State
5. Dead State
90. Explain the difference between >> and >>> operators.
Although they look similar, there is a massive difference between both.
• >> operator does the job of right shifting the sign bits
• >>> operator is used in shifting out the zero-filled bits
91. Brief the life cycle of an applet.
The life cycle of an applet involves the following.
1. Initialization
2. Start
3. Stop
4. Destroy
5. Paint
92. Why are generics used in Java Programming?
Compile-time type safety is provided by using generics. Compile-time type safety allows users to catch
unnecessary invalid types at compile time. Generic methods and classes help programmers specify a
single method declaration, a set of related methods, or related types with an available class declaration.
93. Explain the Externalizable interface.
The Externalizable interface helps with control over the process of serialization. An "externalisable"
interface incorporates readExternal and writeExternal methods.
94. What is the Daemon Thread?
The Daemon thread can be defined as a thread with the least priority. This Daemon thread is designed
to run in the background during the Garbage Collection in Java.
The setDaemon() method creates a Daemon thread in Java.
95. Explain the term enumeration in Java.
Enumeration or enum is an interface in Java. Enum allows the sequential access of the elements stored
in a collection in Java.
96. Why is Java is Dynamic?
Java is designed to adapt to an evolving environment. Java programs include a large amount of runtime
information that is used to resolve access to objects in real-time.
97. Can you run a code before executing the main method?
Yes, we can execute any code, even before the main method. We will be using a static block of code
when creating the objects at the class's load time. Any statements within this static block of code will
get executed at once while loading the class, even before creating objects in the main method.
98. How many times is the finalize method called?
The finalize method is called the Garbage collector. For every object, the Garbage Collector calls the
finalize() method just for one time.
Java Interview Questions for Experienced
Now, lets move on to our last section of Advanced Core Java Interview Questions which is primarly
useful for experienced and working professionals.
99. Can "this" and "super" keywords be used together?
No, "this" and "super" keywords should be used in the first statement in the class constructor. The
following code gives you a brief idea.
public class baseClass {
baseClass() {
super();
this();
System.out.println(" baseClass object is created");
}
public static void main(String []args){
baseClass bclass = new baseClass();
}
}
100. What is a JSP page?
JSP is an abbreviation for Java Servlet Page. The JSP page consists of two types of text.
• Static Data
• JSP elements
Find Our Java Training in Top Cities
India United States Other Countries
Java Training in Bangalore Java Training New York Java Course London
Java Training in Chennai Java Training San Diego Java Course Singapore
Java Training in Hyderabad Java Training Dallas Java Course Melbourne

101. What is JDBC?

JDBC is an abbreviation for Java Database Connector.
JDBC is an abstraction layer used to establish connectivity between an existing database and a Java
application
102. Explain the various directives in JSP.
Directives are instructions processed by JSP Engine. After the JSP page is compiled into a Servlet,
Directives set page-level instructions, insert external files, and define customized tag libraries. Directives
are defined using the symbols below:
start with "< %@" and then end with "% >"
The various types of directives are shown below:
• Include directive
It includes a file and combines the content of the whole file with the currently active pages.
 • Page directive
Page Directive defines specific attributes in the JSP page, like the buffer and error page.
• Taglib
Taglib declares a custom tag library, which is used on the page.
103. What are the observer and observable classes?
Objects that inherit the "Observable class" take care of a list of "observers."
When an Observable object gets upgraded, it calls the update() method of each of its observers.
After that, it notifies all the observers that there is a change of state.
The Observer interface gets implemented by objects that observe Observable objects.
Free Course: JavaScript for Beginners
Learn the Basics of JavaScriptEnroll Now

104. What is Session Management in Java?

A session is essentially defined as the random conversation's dynamic state between the client and the
server. The virtual communication channel includes a string of responses and requests from both sides.
The popular way of implementing session management is establishing a session ID in the client's
communicative discourse and the server.
105. Briefly explain the term Spring Framework.
Spring is essentially defined as an application framework in Java and inversion of control containers for
Java. The spring framework creates enterprise applications in Java. Especially useful to keep in mind that
the spring framework's central features are essentially conducive to any Java application.
106. How to handle exceptions in Spring MVC Framework?
Spring MVC has two approaches for handling the exceptions:
• Exception handler method: In this kind of exception handling, the user will get the
@ExceptionHandler annotation type used to annotate a method to handle exceptions.
• XML Configuration: The user can use the SimpleMappingExceptionResolver bean in Spring’s
application file and map the exception.
107. What is JCA in Java?
Java Cryptography Architecture gives a platform and provides architecture and application programming
interfaces that enable decryption and encryption.
Developers use Java Cryptography Architecture to combine the application with the security
applications. Java Cryptography Architecture helps in implementing third party security rules and
regulations.
Java Cryptography Architecture uses the hash table, encryption message digest, etc. to implement the
security.
108. Explain JPA in Java.
The Java Persistence API enables us to create the persistence layer for desktop and web applications.
Java Persistence deals in the following:
1. Java Persistence API
2. Query Language
3. Java Persistence Criteria API
4. Object Mapping Metadata
109. Explain the different authentications in Java Servlets.
Authentication options are available in Servlets: There are four different options for authentication in
servlet:
• Basic Authentication:
Usernames and passwords are given by the client to authenticate the user.
• Form-based authentication:
In this, the login form is made by the programmer by using HTML.
• Digest Authentication:
It is similar to basic authentication, but the passwords are encrypted using the Hash formula. Hash
Formula makes digest more secure.
• Client certificate Authentication:
It requires that each client accessing the resource has a certificate that it sends to authenticate itself.
Client Authentication requires the SSL protocol.
110. Explain FailFast iterator and FailSafe iterator along with
examples for each.
FailFast iterators and FailSafe iterators are used in Java Collections.
FailFast iterators do not allow changes or modifications to the Java Collections, which means they fail
when the latest element is added to the collection or an existing element gets removed from the
collection. The FailFast iterators tend to fail and throw an exception called
ConcurrentModificationException.
Ex: ArrayList, HashMap
Whereas, on the other hand, FailSafe iterators allow changes or modifications to be done on the Java
Collections. It is possible, as the FailSafe iterators usually operate on the cloned copy of the collection.
Hence, they do not throw any specific exception.
Ex: CopyOnWriteArrayList
111. How do we reverse a string?
The string can be reversed by using the following program.
package simplilearnJava;
public class StringReverse {
public static void main(String args[]) {
String str = "Simplilearn";
String reverse = new StringBuffer(str).reverse().toString();
System.out.printf("Actual Word: %s, Word after reversing %s", str, reverse);
}
public static String reverse(String source) {
if (source == null || source.isEmpty()) {
return source;
}
String reverse = "";
for (int i = source.length() - 1; i >= 0; i--) {
reverse = reverse + source.charAt(i);
}
return reverse;
}
}
Expected Output:
Actual Word: Simplilearn, Word after reversing nraelilpmiS
112. Write a program to find the square root of a number.
The Square root of a number can be found by using the following program.
package simplilearnJava;
import java.util.Scanner;
public class SRoot {
public static void main(String args[]) {
try (Scanner sc = new Scanner(System.in)) {
System.out.println("Input a number to find square root: ");
double square = sc.nextDouble();
double squareRoot = Math.sqrt(square);
System.out.printf("The square root is: %f ", squareRoot);
}
}
}
Expected Output:
Input a number to find square root:
25
The square root is: 5
Free Course: Java Hibernate Fundamentals
Learn Java Hibernate Basic Skills for FreeEnroll Now

113. Write a program that detects the duplicate characters in a string.

The program that finds the duplicate elements in a string is written below:
package simplilearnJava;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class FindDuplicate {
public static void main(String args[]) {
printDuplicateCharacters("Simplilearn");
}
public static void printDuplicateCharacters(String word) {
char[] characters = word.toCharArray();
Map<Character, Integer> charMap = new HashMap<Character, Integer>();
for (Character ch : characters) {
if (charMap.containsKey(ch)) {
charMap.put(ch, charMap.get(ch) + 1);
} else {
charMap.put(ch, 1);
}
}
Set<Map.Entry<Character, Integer>> entrySet = charMap.entrySet();
System.out.printf("List of duplicate characters in String '%s' %n", word);
for (Map.Entry<Character, Integer> entry : entrySet) {
if (entry.getValue() > 1) {
System.out.printf("%s: %d %n", entry.getKey(), entry.getValue());
}
}
}
}
Expected output:
List of duplicate characters in String 'Simplilearn.'
i: 2
l: 2
114. Write a Program to remove duplicates in an ArrayList.
The following program can be implemented to remove duplicate elements in an ArrayList
package simplilearnJava;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class ArrayDuplicate {
public static void main(String args[]) {
List<Integer> num = new ArrayList<Integer>();
num.add(1);
num.add(2);
num.add(3);
num.add(4);
num.add(5);
num.add(6);
num.add(3);
num.add(4);
num.add(5);
num.add(6);
System.out.println("Your list of elements in ArrayList : " + num);
Set<Integer> primesWithoutDuplicates = new LinkedHashSet<Integer>(num);
num.clear();
num.addAll(primesWithoutDuplicates);
System.out.println("list of original numbers without duplication: " + num);
}
}
Expected Output:
Your list of elements in ArrayList : [1, 2, 3, 4, 5, 6, 3, 4, 5, 6]
list of original numbers without duplication: [1, 2, 3, 4, 5, 6]
115. Find the word count in a string using HashMap Collection.
The following program can be used for word count.
package simplilearnJava;
import java.util.HashMap;
public class WordCount {
public static void main(String[] args) {
String str = "Hello World, Welcome to Simplilearn";
String[] split = str.split(" ");
HashMap<String, Integer> map = new HashMap<String, Integer>();
for (int i = 0; i < split.length; i++) {
if (map.containsKey(split[i])) {
int count = map.get(split[i]);
map.put(split[i], count + 1);
} else {
map.put(split[i], 1);
}
}
System.out.println(map);
}
}
Expected Output:
{Hello=1, Simplilearn=1, Welcome=1, to=1, World,=1}
116. Write a program to find the Second Highest number in an
ArrayList
The following program can be used to find the second biggest number in an array list.
package simplilearnJava;
public class NextHighest {
public static void main(String[] args)
{
int array[] = { 1, 2, 3, 4, 11, 12, 13, 14, 21, 22, 23, 24, 31, 32};
int high = 0;
int nextHigh = 0;
System.out.println("The given array is:");
 for (int i = 0; i < array.length; i++)
{
System.out.print(array[i] + "\t");
}
for (int i = 0; i < array.length; i++)
{
if (array[i] > high)
{
nextHigh = high;
high = array[i];
}
else if (array[i] > nextHigh)
{
nextHigh = array[i];
}
}
System.out.println("Second Highest is:" + nextHigh);
System.out.println("Highest Number is: " +high);
}
}
Expected Output:
The given array is:
1 2 3 4 11 12 13 14 21 22 23 24 31 32
Second Highest is:31
The highest number is: 32
117. What is the difference between System.out, System.err, and
System.in?
System.out and System.err represent the monitor by default and thus can be used to send data or
results to the monitor. System.out is used to display normal messages and results. System.eerr is used
to display error messages. System.in represents InputStream object which by default represents
standard input device, i.e., keyboard.
118. Could you provide some implementation of a Dictionary having a
large number of words?
The simplest implementation that can be given is that of a List wherein one can place ordered words
and perform a Binary search. The other implementation with a better search performance is HashMap
where the key is used as the first character of the word and the value as a LinkedList.
Up another level, there are HashMaps like:
hashmap {
a (key) -> hashmap (key-aa , value (hashmap(key-aaa,value)
b (key) -> hashmap (key-ba , value (hashmap(key-baa,value)
z (key) -> hashmap (key-za , value (hashmap(key-zaa,value)
}
Up to n levels where n is the average size of the word in the dictionary.
119. How would you tackle it if you might have to encounter pattern
programs in Java?
Solution - Top 25 Most Frequently asked Pattern Programs in Java
With this, we have come to the end of this Java Interview Questions article. Moving ahead, we will look
into the next crucial steps that you could pursue, to master Java.
120. What do you understand by an instance variable and a local
variable?
Generally, instance variables are declared in a class but outside methods whereas a local variable is
declared within the blocks of code.
//Local Variable
import Java.io.*;
class Main {
public static void main(String[] args)
{
int var = 145;
System.out.println("Local Variable: " + var);
}
}
//Instance variable
import Java.io.*;
class Main {
public int value = 12;
public static void main(String[] args)
{
Main va = new Main();
System.out.println("My value is: " + va.value);
}
}
121. Can the main method be overloaded?
Yes, the main method can be overloaded as many times as we want. Nevertheless, JVM prefers to call
the main method with the help of its predefined calling method.
Example:
class Main {
public static void main(String args[]) {
System.out.println(" Main Method");
}
public static void main(int[] args){
System.out.println("Overloaded Integer array Main Method");
}
public static void main(char[] args){
System.out.println("Overloaded Character array Main Method");
}
public static int main(double[] args){
System.out.println("Overloaded Double array Main Method");
}
public static void main(float args){
System.out.println("Overloaded float Main Method");
}
}
122. Comment on method overloading and overriding by citing
relevant examples.
Method overloading occurs during the compile time, whereas method overriding occurs during the run
time. Static binding is used during overloading, whereas dynamic binding is used during methods
overriding.
//Function overloading
#function1
void addPodium(int a, int b)
{
System.out.println(a + b);
}
#function2
float addPodium(float a, float b, float c)
{
System.out.println(a + b + c);
}
//Function overriding
class Parent {
void show()
{
System.out.println("I am Parent");
}
}
class Child extends Parent {
void show()
{
System.out.println("I am Child");
}
}
class Main {
public static void main(String[] args)
{
Parent obja = new Parent();
obja.show();
Parent objb = new Child();
objb.show();
}
}
123. A single try block and multiple catch blocks can co-exist in a Java
Program. Explain.
One or more catch blocks can follow a try block. Each catch block must have a unique exception handler.
So, if you want to perform multiple tasks in response to various exceptions, use the Java multi-catch
block.
124. Do final, finally and finalize keywords have the same function?
No, final, finally and finalize keywords have different functionalities.
Final is used to restrict classes, variables, or methods, the final keyword.
Finally is used to execute the code written inside the block without handling any exceptions.
Finalize is used to call the function of the implementation of cleaning the garbage collection of an
object.
125. When can you use the "super" keyword?
Basically, the super keyword is used to refer to the parent class. When there are the same fields in both
parent and child classes, then one can use a super keyword to access data members of the parent class.
126. What are shallow copy and deep copy in Java?
In the case of a shallow copy, primitive data types are copied, whereas in the case of a deep copy along
with primitive data types the object references are also copied.
127. Using relevant properties highlight the differences between
interfaces and abstract classes.
An abstract class can have a combination of both abstract and non-abstract methods, whereas an
interface has only abstract methods in it.
128. What are the different ways of thread usage?
There are two ways to define and implement a thread in Java. They are by implementing the runnable
interface and extending the thread class.
Extending the Thread class
class InterviewBitThreadExample extends Thread{
public void run(){
System.out.println("Thread runs...");
}
public static void main(String args[]){
InterviewBitThreadExample ib = new InterviewBitThreadExample();
ib.start();
}
}
Implementing the Runnable interface
class InterviewBitThreadExample implements Runnable{
public void run(){
System.out.println("Thread runs...");
}
public static void main(String args[]){
Thread ib = new Thread(new InterviewBitThreadExample());
ib.start();
}
}
Implementing a thread using the method of Runnable interface is more preferred and advantageous as
Java does not have support for multiple inheritances of classes.
start() method is used for creating a separate call stack for the thread execution. Once the call stack is
created, JVM calls the run() method for executing the thread in that call stack.
129. What is the difference between the ‘throw' and ‘throws'
keyword in Java?
The throw keyword is often used to explicitly throw an exception. It can only throw one exception at a
time whereas throws can be used to declare multiple exceptions.
130. Identify the output of the below Java program and Justify your
answer.
class Main {
public static void main(String args[]) {
Scaler s = new Scaler(5);
}
}
class InterviewBit{
InterviewBit(){
System.out.println(" Welcome to InterviewBit ");
}
}
class Scaler extends InterviewBit{
Scaler(){
System.out.println(" Welcome to Scaler Academy ");
}
Scaler(int x){
this();
super();
System.out.println(" Welcome to Scaler Academy 2");
}
}
The above code will throw the compilation error. It is because the super() is used to call the parent class
constructor. But there is the condition that super() must be the first statement in the block. Now in this
case, if we replace this() with super() then also it will throw the compilation error. Because this() also
has to be the first statement in the block. So in conclusion, we can say that we cannot use this() and
super() keywords in the same block.
131. Java works as a “pass by value” or “pass by reference”
phenomenon?
Java works as a “pass by value” phenomenon, because “pass by reference” needs the help of pointers.
But there are no pointers in Java.
132. How to not allow serialization of attributes of a class in Java?
One approach to not allow serialization of attributes of a class in Java is by using writeObject() and
readObject() methods in the subclass and throwing a not Serializable exception.
133. What are the default values assigned to variables and instances
in Java?
By default, for a numerical value it is 0, for the boolean value it is false and for objects it is NULL.
134. What do you mean by data encapsulation?
Data encapsulation is one of the properties of OOPS concepts, where all the data such as variables and
methods are enclosed together as a single unit.
135. Can you tell the difference between equals() method and
equality operator (==) in Java?
Equality operator (==) is used to check the equality condition between two variables. But the equals()
method is used to check the equality condition between two objects.
136. How is an infinite loop declared in Java?
An infinite loop can be declared in Java by breaking the logic in the instruction block. For example,
for(int i = 1; i > 0; i++)
{
//statements
}
The above code forms an infinite loop in Java.
137. Briefly explain the concept of constructor overloading
The concept of constructor overloading refers to having multiple methods in a class with their name
being the same as the class name. The difference lies in the set of parameters passed to the functions.
138. Explain the use of the final keyword in variable, method and
class.
In Java, one can apply the final keyword to a variable, methods, and class. With the help of the final
keyword, the variable turns out to be a constant, the method cannot be inherited and the class cannot
be overridden.
139. Is it possible that the ‘finally' block will not be executed? If yes
then list the case.
Yes, there is a possibility that the ‘finally’ block cannot get executed. Here are some of the cases where
the above situation occurs.
1. During the time of fatal errors such as memory exhaustion, memory access error, etc.
2. During the time of using System.exit()
140. Difference between static methods, static variables, and static
classes in Java.
A variable, method, or class can be made static by using the static keyword. A static class cannot be
instantiated. When both objects or instances of a class share the same variables, this is referred to as
static variables. Static methods are simply methods that refer to the class in which they are written.
141. What is the main objective of garbage collection?
The main goal of using garbage collection is to free the heap memory by eliminating unnecessary
objects.
142. Apart from the security aspect, what are the reasons behind
making strings immutable in Java?
Because of security, synchronization, concurrency, caching, and class loading, the String is immutable in
Java. The reason for making string final would be to destroy its immutability and help stop others from
trying to extend it. String objects are cached in the String pool, making them immutable.
143. Which of the below generates a compile-time error? State the
reason.
int[] n1 = new int[0];
boolean[] n2 = new boolean[-200];
double[] n3 = new double[2241423798];
char[] ch = new char[20];
We get a compile-time error in line 3. The error we will get in Line 3 is - the integer number too large. It
is because the array requires size as an integer. And Integer takes 4 Bytes in the memory. And the
number (2241423798) is beyond the capacity of the integer. The maximum array size we can declare is -
(2147483647).
Because the array requires the size in integer, none of the lines (1, 2, and 4) will give a compile-time
error. The program will compile fine. But we get the runtime exception in line 2. The exception is -
NegativeArraySizeException.
Here what will happen is - At the time when JVM will allocate the required memory during runtime then
it will find that the size is negative. And the array size can’t be negative. So the JVM will throw the
exception.
144. How would you differentiate between a String, StringBuffer, and
a StringBuilder?
The string class is immutable but the other two are mutable in nature. StringBuffer is synchronous
whereas the StringBuilder is asynchronous. String uses string pool as memory storage whereas the other
two use heap memory for storage purposes.
145. What is a Comparator in Java?
A comparator is an interface, which is used to sort the objects.
146. In Java, static as well as private method overriding is possible.
Comment on the statement.
In Java, you could indeed override a private or static method. If you create a similar method in a child
class with the same return type and method arguments, it will hide the super class method; this is
known as method hiding. Similarly, you cannot override a private method in a subclass because it is not
accessible from that.
147. What makes a HashSet different from a TreeSet?
In a HashSet, the elements are unsorted and work faster than a Tree set. It is implemented using a hash
table.
148. Why is the character array preferred over string for storing
confidential information?
Because Strings are immutable, any change will result in the creation of a new String, whereas char[]
allows you to set all of the elements to blank or zero. So storing a password in a character array clearly
reduces the security risk of password theft.
149. What are the differences between HashMap and HashTable in
Java?
HashMap HashTable
1. Asynchronous in nature 1. Synchronous in nature
2. Not thread-safe 2. Thread safe
3. It allows one null key and null values 3. It doesn’t allow null keys and values.

150. What is the importance of reflection in Java?

Reflection is a property of Java, enabling the Java code to inspect itself. A Java class, for example, can get
the names of all its members and showcase them.
151. What are the different types of Thread Priorities in Java? And
what is the default priority of a thread assigned by JVM?
There are different types of thread properties in Java. They are MIN_PRIORITY, MAX_PRIORITY, and
NORM_PRIORITY. By default, the thread is assigned NORM_PRIORITY.
152. What is the ‘IS-A ‘ relationship in OOPs Java?
‘IS-A’ relationship is related to the Inheritance property of OOPs Java. It is a kind of parent-child
relationship that is established between two classes.

From <https://www.simplilearn.com/tutorials/java-tutorial/java-interview-questions>
Java Interview Questions from sedureka
Monday, February 13, 2023 11:27 PM

Q1. Explain JDK, JRE and JVM?

JDK JRE JVM
It stands for Java It stands for Java Runtime It stands for Java Virtual Machine.
Development Kit. Environment.
It is the tool necessary to JRE refers to a runtime It is an abstract machine. It is a
compile, document and environment in which Java specification that provides a run-time
package Java programs. bytecode can be executed. environment in which Java bytecode can
be executed.
It contains JRE + It’s an implementation of the JVM follows three notations: Specification,
development tools. JVM which physically exists. Implementation, and Runtime Instance.
JDK vs JRE vs JVM
Q2. Explain public static void main(String args[]) in Java.
main() in Java is the entry point for any Java program. It is always written as public static void
main(String[] args).
• public: Public is an access modifier, which is used to specify who can access this method. Public
means that this Method will be accessible by any Class.
• static: It is a keyword in java which identifies it is class-based. main() is made static in Java so that
it can be accessed without creating the instance of a Class. In case, main is not made static then
the compiler will throw an error as main() is called by the JVM before any objects are made and
only static methods can be directly invoked via the class.
• void: It is the return type of the method. Void defines the method which will not return any value.
• main: It is the name of the method which is searched by JVM as a starting point for an application
with a particular signature only. It is the method where the main execution occurs.
• String args[]: It is the parameter passed to the main method.
Q3. Why Java is platform independent?
Java is called platform independent because of its byte codes which can run on any system irrespective
of its underlying operating system.
Q4. Why Java is not 100% Object-oriented?
Java is not 100% Object-oriented because it makes use of eight primitive data types such as boolean,
byte, char, int, float, double, long, short which are not objects.
Q5. What are wrapper classes in Java?
Wrapper classes convert the Java primitives into the reference types (objects). Every primitive data type
has a class dedicated to it. These are known as wrapper classes because they “wrap” the primitive data
type into an object of that class. Refer to the below image which displays different primitive type,
wrapper class and constructor argument.
Q6. What are constructors in Java?
In Java, constructor refers to a block of code which is used to initialize an object. It must have the same
name as that of the class. Also, it has no return type and it is automatically called when an object is
created.
There are two types of constructors:
1. Default Constructor: In Java, a default constructor is the one which does not take any inputs. In
other words, default constructors are the no argument constructors which will be created by
default in case you no other constructor is defined by the user. Its main purpose is to initialize the
instance variables with the default values. Also, it is majorly used for object creation.
2. Parameterized Constructor: The parameterized constructor in Java, is the constructor which is
capable of initializing the instance variables with the provided values. In other words, the
constructors which take the arguments are called parameterized constructors.
Q7. What is singleton class in Java and how can we make a class
singleton?
Singleton class is a class whose only one instance can be created at any given time, in one JVM. A class
can be made singleton by making its constructor private.
Q8. What is the difference between Array list and vector in Java?
ArrayList Vector
Array List is not synchronized. Vector is synchronized.
Array List is fast as it’s non-synchronized. Vector is slow as it is thread safe.
If an element is inserted into the Array List, it increases Vector defaults to doubling size of its array.
its Array size by 50%.
Array List does not define the increment size. Vector defines the increment size.
Array List can only use Iterator for traversing an Array Vector can use both Enumeration and
List. Iterator for traversing.

Q9. What is the difference between equals() and == in Java?

Equals() method is defined in Object class in Java and used for checking equality of two objects defined
by business logic.
“==” or equality operator in Java is a binary operator provided by Java programming language and used
to compare primitives and objects. public boolean equals(Object o) is the method provided by the Object
class. The default implementation uses == operator to compare two objects. For example: method can
be overridden like String class. equals() method is used to compare the values of two objects.

Java Certification Training Course

• Instructor-led Sessions
• Real-life Case Studies
• Assignments
• Lifetime Access
Q10. When can you use the super keyword?
In Java, the super keyword is a reference variable that refers to an immediate parent class object.
When you create a subclass instance, you’re also creating an instance of the parent class, which is
referenced to by the super reference variable.
The uses of the Java super Keyword are-
1. To refer to an immediate parent class instance variable, use super.
2. The keyword super can be used to call the method of an immediate parent class.
3. Super() can be used to call the constructor of the immediate parent class.

Q11. What makes a HashSet different from a TreeSet?

HashSet TreeSet
It is implemented through a hash table. TreeSet implements SortedSet Interface that uses
trees for storing data.
It permits the null object. It does not allow the null object.
It is faster than TreeSet especially for search, insert, It is slower than HashSet for these operations.
and delete operations.
It does not maintain elements in an ordered way. The elements are maintained in a sorted order.
It uses equals() method to compare two objects. It uses compareTo() method for comparing two
objects.
It does not permit a heterogenous object. It permits a heterogenous object.

Q12. What are the differences between HashMap and HashTable in Java?

HashMap Hashtable
It is non synchronized. It cannot be shared between many It is synchronized. It is thread-safe and can
threads without proper synchronization code. be shared with many threads.
It permits one null key and multiple null values. It does not permit any null key or value.
is a new class introduced in JDK 1.2. It was present in earlier versions of java as
well.
It is faster. It is slower.
It is traversed through the iterator. It is traversed through Enumerator and
Iterator.
It uses fail fast iterator. It uses an enumerator which is not fail
fast.
It inherits AbstractMap class. It inherits Dictionary class.

Q13. What is the importance of reflection in Java?

Reflection is a runtime API for inspecting and changing the behavior of methods, classes, and interfaces.
Java Reflection is a powerful tool that can be really beneficial. Java Reflection allows you to analyze
classes, interfaces, fields, and methods during runtime without knowing what they are called at compile
time. Reflection can also be used to create new objects, call methods, and get/set field values. External,
user-defined classes can be used by creating instances of extensibility objects with their fully-qualified
names. Debuggers can also use reflection to examine private members of classes.
Q14. How to not allow serialization of attributes of a class in Java?
The Non-Serialized attribute can be used to prevent member variables from being serialized.
You should also make an object that potentially contains security-sensitive data non-serializable if
possible. Apply the Non-Serialized attribute to certain fields that store sensitive data if the object must
be serialized. If you don’t exclude these fields from serialization, the data they store will be visible to any
programs with serialization permission.
Q15. Can you call a constructor of a class inside another constructor?
Yes, we can call a constructor of a class inside another constructor. This is also called as constructor
chaining. Constructor chaining can be done in 2 ways-
1. Within the same class: For constructors in the same class, the this() keyword can be used.
2. From the base class: The super() keyword is used to call the constructor from the base class.
The constructor chaining follows the process of inheritance. The constructor of the sub class first
calls the constructor of the super class. Due to this, the creation of sub class’s object starts with
the initialization of the data members of the super class. The constructor chaining works similarly
with any number of classes. Every constructor keeps calling the chain till the top of the chain.

Q16. Contiguous memory locations are usually used for storing actual values in an array but not in
ArrayList. Explain.
An array generally contains elements of the primitive data types such as int, float, etc. In such cases, the
array directly stores these elements at contiguous memory locations. While an ArrayList does not
contain primitive data types. An arrayList contains the reference of the objects at different memory
locations instead of the object itself. That is why the objects are not stored at contiguous memory
locations.

Q17. How is the creation of a String using new() different from that of a literal?
When we create a string using new(), a new object is created. Whereas, if we create a string using the
string literal syntax, it may return an already existing object with the same name.

Q18. Why is synchronization necessary? Explain with the help of a relevant example.
Java allows multiple threads to execute. They may be accessing the same variable or object.
Synchronization helps to execute threads one after another.
It is important as it helps to execute all concurrent threads while being in sync. It prevents memory
consistency errors due to access to shared memory. An example of synchronization code is-
Programming & Frameworks Training

1 public synchronized void increment()

2 {
3 a++;
4 }

As we have synchronized this function, this thread can only use the object after the previous thread has
used it.
Q19. Explain the term “Double Brace Initialization” in Java?
Double Brace Initialization is a Java term that refers to the combination of two independent processes.
There are two braces used in this. The first brace creates an anonymous inner class. The second brace is
an initialization block. When these both are used together, it is known as Double Brace Initialization. The
inner class has a reference to the enclosing outer class, generally using the ‘this’ pointer. It is used to do
both creation and initialization in a single statement. It is generally used to initialize collections. It
reduces the code and also makes it more readable.

Q20. Why is it said that the length() method of String class doesn’t return accurate results?
The length() method of String class doesn’t return accurate results because
it simply takes into account the number of characters within in the String. In other words, code points
outside of the BMP (Basic Multilingual Plane), that is, code points having a value of U+10000 or above,
will be ignored.
The reason for this is historical. One of Java’s original goals was to consider all text as Unicode; yet,
Unicode did not define code points outside of the BMP at the time. It was too late to modify char by the
time Unicode specified such code points.

Q21. What are the differences between Heap and Stack Memory in Java?
The major difference between Heap and Stack memory are:
Features Stack Heap
Memory Stack memory is used only by one thread of Heap memory is used by all the parts of
execution. the application.
Access Stack memory can’t be accessed by other Objects stored in the heap are globally
threads. accessible.
Memory Follows LIFO manner to free memory. Memory management is based on the
Management generation associated with each object.
Lifetime Exists until the end of execution of the Heap memory lives from the start till
thread. the end of application execution.
Usage Stack memory only contains local primitive Whenever an object is created, it’s
and reference variables to objects in heap always stored in the Heap space.
space.

Q22. What is a package in Java? List down various advantages of

packages.
Packages in Java, are the collection of related classes and interfaces which are bundled together. By
using packages, developers can easily modularize the code and optimize its reuse. Also, the code within
the packages can be imported by other classes and reused. Below I have listed down a few of its
advantages:
• Packages help in avoiding name clashes
• They provide easier access control on the code
• Packages can also contain hidden classes which are not visible to the outer classes and only used
within the package
• Creates a proper hierarchical structure which makes it easier to locate the related classes
Q23. Why pointers are not used in Java?
Java doesn’t use pointers because they are unsafe and increases the complexity of the program. Since,
Java is known for its simplicity of code, adding the concept of pointers will be contradicting. Moreover,
since JVM is responsible for implicit memory allocation, thus in order to avoid direct access to memory
by the user, pointers are discouraged in Java.
Q24. What is JIT compiler in Java?
JIT stands for Just-In-Time compiler in Java. It is a program that helps in converting the Java bytecode
into instructions that are sent directly to the processor. By default, the JIT compiler is enabled in Java
and is activated whenever a Java method is invoked. The JIT compiler then compiles the bytecode of the
invoked method into native machine code, compiling it “just in time” to execute. Once the method has
been compiled, the JVM summons the compiled code of that method directly rather than interpreting it.
This is why it is often responsible for the performance optimization of Java applications at the run time.
Q25. What are access modifiers in Java?
In Java, access modifiers are special keywords which are used to restrict the access of a class,
constructor, data member and method in another class. Java supports four types of access modifiers:
1. Default
2. Private
3. Protected
4. Public
Modifier Default Private Protected Public
Same class YES YES YES YES
Same Package subclass YES NO YES YES
Same Package non-subclass YES NO YES YES
Different package subclass NO NO YES YES
Different package non-subclass NO NO NO YES

Q26. Define a Java Class.

A class in Java is a blueprint which includes all your data. A class contains fields (variables) and methods
to describe the behavior of an object. Let’s have a look at the syntax of a class.
1 class Abc {
2 member variables // class body
3 methods}

Q27. What is an object in Java and how is it created?

An object is a real-world entity that has a state and behavior. An object has three characteristics:
1. State
2. Behavior
3. Identity
An object is created using the ‘new’ keyword. For example:
ClassName obj = new ClassName();
Q28. What is Object Oriented Programming?
Object-oriented programming or popularly known as OOPs is a programming model or approach where
the programs are organized around objects rather than logic and functions. In other words, OOP mainly
focuses on the objects that are required to be manipulated instead of logic. This approach is ideal for
the programs large and complex codes and needs to be actively updated or maintained.
Q29. What are the main concepts of OOPs in Java?
Object-Oriented Programming or OOPs is a programming style that is associated with concepts like:
1. Inheritance: Inheritance is a process where one class acquires the properties of another.
2. Encapsulation: Encapsulation in Java is a mechanism of wrapping up the data and code together as
a single unit.
3. Abstraction: Abstraction is the methodology of hiding the implementation details from the user
and only providing the functionality to the users.
4. Polymorphism: Polymorphism is the ability of a variable, function or object to take multiple forms.
Q30. What is the difference between a local variable and an instance
variable?
In Java, a local variable is typically used inside a method, constructor, or a block and has only local
scope. Thus, this variable can be used only within the scope of a block. The best benefit of having a local
variable is that other methods in the class won’t be even aware of that variable.
Example
1 if(x > 100)
2 {
3 String test = "Edureka";
4 }
Whereas, an instance variable in Java, is a variable which is bounded to its object itself. These variables
are declared within a class, but outside a method. Every object of that class will create it’s own copy of
the variable while using it. Thus, any changes made to the variable won’t reflect in any other instances
of that class and will be bound to that particular instance only.
1 class Test{
2 public String EmpName;
3 public int empAge;
4 }

Q31. Differentiate between the constructors and methods in Java?

Methods Constructors
1. Used to represent the behavior of an 1. Used to initialize the state of an object
object
2. Must have a return type 2. Do not have any return type
3. Needs to be invoked explicitly 3. Is invoked implicitly
4. No default method is provided by the 4. A default constructor is provided by the compiler if the
compiler class has none
5. Method name may or may not be same as 5. Constructor name must always be the same as the
class name class name
In case you are facing any challenges with these Core Java interview questions, please comment on your
problems in the section below.
Q32. What is final keyword in Java?
final is a special keyword in Java that is used as a non-access modifier. A final variable can be used in
different contexts such as:
• final variable
When the final keyword is used with a variable then its value can’t be changed once assigned. In case
the no value has been assigned to the final variable then using only the class constructor a value can be
assigned to it.

Java Certification Training Course

Weekday / Weekend Batches
• final method
When a method is declared final then it can’t be overridden by the inheriting class.
• final class
When a class is declared as final in Java, it can’t be extended by any subclass class but it can extend
other class.
Q33. What is the difference between break and continue statements?
break continue
1. Can be used in switch and loop (for, while, do 1. Can be only used with loop statements
while) statements
2. It causes the switch or loop statements to 2. It doesn’t terminate the loop but causes the loop to
terminate the moment it is executed jump to the next iteration
3. It terminates the innermost enclosing loop 3. A continue within a loop nested with a switch will
or switch immediately cause the next loop iteration to execute
Example break:
1 for (int i = 0; i < 5; i++)
2 {
3 if (i == 3)
4 {
5 break;
6 }
7 System.out.println(i);
8 }
Example continue:
1 for (int i = 0; i < 5; i++)
2 {
3 if(i == 2)
4 {
5 continue;
6 }
7 System.out.println(i);
8 }

Q34. What is an infinite loop in Java? Explain with an example.

An infinite loop is an instruction sequence in Java that loops endlessly when a functional exit isn’t met.
This type of loop can be the result of a programming error or may also be a deliberate action based on
the application behavior. An infinite loop will terminate automatically once the application exits.
For example:
1 public class InfiniteForLoopDemo
2 {
3 public static void main(String[] arg) {
4 for(;;)
5 System.out.println("Welcome to Edureka!");
6 // To terminate this program press ctrl + c in the console.
7 }
8 }

Q35. What is the difference between this() and super() in Java?

In Java, super() and this(), both are special keywords that are used to call the constructor.
this() super()
1. this() represents the current instance of a 1. super() represents the current instance of a
class parent/base class
2. Used to call the default constructor of the 2. Used to call the default constructor of the
same class parent/base class
3. Used to access methods of the current class 3. Used to access methods of the base class
4. Used for pointing the current class instance 4. Used for pointing the superclass instance
5. Must be the first line of a block 5. Must be the first line of a block

Q36. What is Java String Pool?

Java String pool refers to a collection of Strings which are stored in heap memory. In this, whenever a
new object is created, String pool first checks whether the object is already present in the pool or not. If
it is present, then the same reference is returned to the variable else new object will be created in the
String pool and the respective reference will be returned.

Q37. Differentiate between static and non-static methods in Java.

Static Method Non-Static Method
1. The static keyword must be used 1. No need to use the static keyword before the method
before the method name name
2. It is called using the class 2. It is can be called like any general method
(className.methodName)
3. They can’t access any non-static 3. It can access any static method and any static variable
instance variables or methods without creating an instance of the class

Q38. Explain the term “Double Brace Initialisation” in Java?

Double Brace Initialization is a Java term that refers to the combination of two independent processes.
There are two braces used in this. The first brace creates an anonymous inner class. The second brace is
an initialization block. When these both are used together, it is known as Double Brace Initialisation. The
inner class has a reference to the enclosing outer class, genertally using the ‘this’ pointer. It is used to do
both creation and initialization in a single statement. It is generally used to initialize collections. It
reduces the code and also makes it more readable.
Q39. What is constructor chaining in Java?
In Java, constructor chaining is the process of calling one constructor from another with respect to the
current object. Constructor chaining is possible only through legacy where a subclass constructor is
responsible for invoking the superclass’ constructor first. There could be any number of classes in the
constructor chain. Constructor chaining can be achieved in two ways:
1. Within the same class using this()
2. From base class using super()
Q40. Difference between String, StringBuilder, and StringBuffer.
Factor String StringBuilder StringBuffer
Storage Area Constant String Pool Heap Area Heap Area
Mutability Immutable Mutable Mutable
Thread Safety Yes No Yes
Performance Fast More efficient Less efficient
If you think this article on Java Interview Questions is helpful, you can check out Edureka’s Java Training
in Chennai as well.
Q41. What is a classloader in Java?
The Java ClassLoader is a subset of JVM (Java Virtual Machine) that is responsible for loading the class
files. Whenever a Java program is executed it is first loaded by the classloader. Java provides three built-
in classloaders:
1. Bootstrap ClassLoader
2. Extension ClassLoader
3. System/Application ClassLoader
Q42. Why Java Strings are immutable in nature?
In Java, string objects are immutable in nature which simply means once the String object is created its
state cannot be modified. Whenever you try to update the value of that object instead of updating the
values of that particular object, Java creates a new string object. Java String objects are immutable as
String objects are generally cached in the String pool. Since String literals are usually shared between
multiple clients, action from one client might affect the rest. It enhances security, caching,
synchronization, and performance of the application.
Q43. What is the difference between an array and an array list?
Array ArrayList
Cannot contain values of different data types Can contain values of different data types.
Size must be defined at the time of Size can be dynamically changed
declaration
Need to specify the index in order to add No need to specify the index
data
Arrays are not type parameterized Arraylists are type
Arrays can contain primitive data types as Arraylists can contain only objects, no primitive data
well as objects types are allowed

Q44. What is a Map in Java?

In Java, Map is an interface of Util package which maps unique keys to values. The Map interface is not a
subset of the main Collection interface and thus it behaves little different from the other collection
types. Below are a few of the characteristics of Map interface:
1. Map doesn’t contain duplicate keys.
2. Each key can map at max one value.
Q45. What is collection class in Java? List down its methods and
interfaces.
In Java, the collection is a framework that acts as an architecture for storing and manipulating a group of
objects. Using Collections you can perform various tasks like searching, sorting, insertion, manipulation,
deletion, etc. Java collection framework includes the following:
• Interfaces
• Classes
• Methods
The below image shows the complete hierarchy of the Java Collection.

Want to upskill yourself to get ahead in Career? Check out this video
Core Java Interview Quesions And Answers for Freshers and Experienced
This 120+ core java interview question and answer will help freshers and experience to crack the
interview in 1st attempt.

OOPS Java Interview Questions

Q1. What is Polymorphism?
Polymorphism is briefly described as “one interface, many implementations”. Polymorphism is a
characteristic of being able to assign a different meaning or usage to something in different contexts –
specifically, to allow an entity such as a variable, a function, or an object to have more than one form.
There are two types of polymorphism:

1. Compile time polymorphism

2. Run time polymorphism
Compile time polymorphism is method overloading whereas Runtime time polymorphism is done using
inheritance and interface.
Q2. What is runtime polymorphism or dynamic method dispatch?
In Java, runtime polymorphism or dynamic method dispatch is a process in which a call to an overridden
method is resolved at runtime rather than at compile-time. In this process, an overridden method is
called through the reference variable of a superclass. Let’s take a look at the example below to
understand it better.
1 class Car {
2 void run()
3 {
4 System.out.println(&ldquo;car is running&rdquo;);
5 }
6 }
7 class Audi extends Car {
8 void run()
9 {
10 System.out.prinltn(&ldquo;Audi is running safely with 100km&rdquo;);
11 }
12 public static void main(String args[])
13 {
14 Car b= new Audi(); //upcasting
15 b.run();
16 }
17 }

Q3. What is abstraction in Java?

Abstraction refers to the quality of dealing with ideas rather than events. It basically deals with hiding
the details and showing the essential things to the user. Thus you can say that abstraction in Java is the
process of hiding the implementation details from the user and revealing only the functionality to them.
Abstraction can be achieved in two ways:
1. Abstract Classes (0-100% of abstraction can be achieved)
2. Interfaces (100% of abstraction can be achieved)
Q4. What do you mean by an interface in Java?
An interface in Java is a blueprint of a class or you can say it is a collection of abstract methods and static
constants. In an interface, each method is public and abstract but it does not contain any constructor.
Thus, interface basically is a group of related methods with empty bodies. Example:
public interface Animal {
public void eat();
public void sleep();
public void run();
}
Q5. What is the difference between abstract classes and interfaces?
Abstract Class Interfaces
An abstract class can provide complete, default An interface cannot provide any code at all, just
code and/or just the details that have to be the signature
overridden
In the case of an abstract class, a class may extend A Class may implement several interfaces
only one abstract class
An abstract class can have non-abstract methods All methods of an Interface are abstract
An abstract class can have instance variables An Interface cannot have instance variables
An abstract class can have any visibility: public, An Interface visibility must be public (or) none
private, protected
If we add a new method to an abstract class then If we add a new method to an Interface then we
we have the option of providing default have to track down all the implementations of the
implementation and therefore all the existing code interface and define implementation for the new
might work properly method
An abstract class can contain constructors An Interface cannot contain constructors
Abstract classes are fast Interfaces are slow as it requires extra indirection
to find the corresponding method in the actual
class
Q6. What is inheritance in Java?
Inheritance in Java is the concept where the properties of one class can be inherited by the other. It
helps to reuse the code and establish a relationship between different classes. Inheritance is performed
between two types of classes:
1. Parent class (Super or Base class)
2. Child class (Subclass or Derived class)
A class which inherits the properties is known as Child Class whereas a class whose properties are
inherited is known as Parent class.
Q7. What are the different types of inheritance in Java?
Java supports four types of inheritance which are:
1. Single Inheritance: In single inheritance, one class inherits the properties of another i.e there will
be only one parent as well as one child class.
2. Multilevel Inheritance: When a class is derived from a class which is also derived from another
class, i.e. a class having more than one parent class but at different levels, such type of inheritance
is called Multilevel Inheritance.
3. Hierarchical Inheritance: When a class has more than one child classes (subclasses) or in other
words, more than one child classes have the same parent class, then such kind of inheritance is
known as hierarchical.
4. Hybrid Inheritance: Hybrid inheritance is a combination of two or more types of inheritance.
Q8. What is method overloading and method overriding?
Method Overloading :
• In Method Overloading, Methods of the same class shares the same name but each method must
have a different number of parameters or parameters having different types and order.
• Method Overloading is to “add” or “extend” more to the method’s behavior.
• It is a compile-time polymorphism.
• The methods must have a different signature.
• It may or may not need inheritance in Method Overloading.
Let’s take a look at the example below to understand it better.
1 class Adder {
2 Static int add(int a, int b)
3 {
4 return a+b;
5 }
6 Static double add( double a, double b)
7 {
8 return a+b;
9 }
10 public static void main(String args[])
11 {
12 System.out.println(Adder.add(11,11));
13 System.out.println(Adder.add(12.3,12.6));
14 }}
Method Overriding:
• In Method Overriding, the subclass has the same method with the same name and exactly the
same number and type of parameters and same return type as a superclass.
• Method Overriding is to “Change” existing behavior of the method.
• It is a run time polymorphism.
• The methods must have the same signature.
• It always requires inheritance in Method Overriding.
Let’s take a look at the example below to understand it better.
1 class Car {
2 void run(){
3 System.out.println(&ldquo;car is running&rdquo;);
4 }
5 Class Audi extends Car{
6 void run()
7 {
8 System.out.prinltn("Audi is running safely with 100km");
9 }
10 public static void main( String args[])
11 {
12 Car b=new Audi();
13 b.run();
14 }
15 }

Q9. Can you override a private or static method in Java?

You cannot override a private or static method in Java. If you create a similar method with the same
return type and same method arguments in child class then it will hide the superclass method; this is
known as method hiding. Similarly, you cannot override a private method in subclass because it’s not
accessible there. What you can do is create another private method with the same name in the child
class. Let’s take a look at the example below to understand it better.
1 class Base {
2 private static void display() {
3 System.out.println("Static or class method from Base");
4 }
5 public void print() {
6 System.out.println("Non-static or instance method from Base");
7 }
8 class Derived extends Base {
9 private static void display() {
10 System.out.println("Static or class method from Derived");
11 }
12 public void print() {
13 System.out.println("Non-static or instance method from Derived");
14 }
15 public class test {
16 public static void main(String args[])
17 {
18 Base obj= new Derived();
19 obj1.display();
20 obj1.print();
21 }
22 }
Q10. What is multiple inheritance? Is it supported by Java?

If a child class inherits the property from multiple classes is known as multiple inheritance. Java does not
allow to extend multiple classes.
The problem with multiple inheritance is that if multiple parent classes have the same method name,
then at runtime it becomes difficult for the compiler to decide which method to execute from the child
class.
Therefore, Java doesn’t support multiple inheritance. The problem is commonly referred to as Diamond
Problem.
In case you are facing any challenges with these java interview questions, please comment on your
problems in the section below.
Q11. What is encapsulation in Java?
Encapsulation is a mechanism where you bind your data(variables) and code(methods) together as a
single unit. Here, the data is hidden from the outer world and can be accessed only via current class
methods. This helps in protecting the data from any unnecessary modification. We can achieve
encapsulation in Java by:
• Declaring the variables of a class as private.
• Providing public setter and getter methods to modify and view the values of the variables.
Q12. What is an association?
Association is a relationship where all object have their own lifecycle and there is no owner. Let’s take
the example of Teacher and Student. Multiple students can associate with a single teacher and a single
student can associate with multiple teachers but there is no ownership between the objects and both
have their own lifecycle. These relationships can be one to one, one to many, many to one and many to
many.
Q13. What do you mean by aggregation?
An aggregation is a specialized form of Association where all object has their own lifecycle but there is
ownership and child object can not belong to another parent object. Let’s take an example of
Department and teacher. A single teacher can not belong to multiple departments, but if we delete the
department teacher object will not destroy.
Q14. What is composition in Java?
Composition is again a specialized form of Aggregation and we can call this as a “death” relationship. It is
a strong type of Aggregation. Child object does not have their lifecycle and if parent object deletes all
child object will also be deleted. Let’s take again an example of a relationship between House and
rooms. House can contain multiple rooms there is no independent life of room and any room can not
belongs to two different houses if we delete the house room will automatically delete.
Q15. What is a marker interface?
A Marker interface can be defined as the interface having no data member and member functions. In
simpler terms, an empty interface is called the Marker interface. The most common examples of Marker
interface in Java are Serializable, Cloneable etc. The marker interface can be declared as follows.
1 public interface Serializable{
2 }
Q16. What is object cloning in Java?
Object cloning in Java is the process of creating an exact copy of an object. It basically means the ability
to create an object with a similar state as the original object. To achieve this, Java provides a method
clone() to make use of this functionality. This method creates a new instance of the class of the current
object and then initializes all its fields with the exact same contents of corresponding fields. To object
clone(), the marker interface java.lang.Cloneable must be implemented to avoid any runtime
exceptions. One thing you must note is Object clone() is a protected method, thus you need to override
it.
Q17. What is a copy constructor in Java?
Copy constructor is a member function that is used to initialize an object using another object of the
same class. Though there is no need for copy constructor in Java since all objects are passed by
reference. Moreover, Java does not even support automatic pass-by-value.
Q18. What is a constructor overloading in Java?
In Java, constructor overloading is a technique of adding any number of constructors to a class each
having a different parameter list. The compiler uses the number of parameters and their types in the list
to differentiate the overloaded constructors.
1 class Demo
2 {
3 int i;
4 public Demo(int a)
5 {
6 i=k;
7 }
8 public Demo(int a, int b)
9 {
10 //body
11 }
12 }
In case you are facing any challenges with these java interview questions, please comment on your
problems in the section below. Apart from this Java Interview Questions Blog, if you want to get trained
from professionals on this technology, you can opt for a structured training from edureka!
Servlets – Java Interview Questions
Q1. What is a servlet?
• Java Servlet is server-side technologies to extend the capability of web servers by providing
support for dynamic response and data persistence.
• The javax.servlet and javax.servlet.http packages provide interfaces and classes for writing our
own servlets.
• All servlets must implement the javax.servlet.Servlet interface, which defines servlet lifecycle
methods. When implementing a generic service, we can extend the GenericServlet class provided
with the Java Servlet API. The HttpServlet class provides methods, such as doGet() and doPost(),
for handling HTTP-specific services.
• Most of the times, web applications are accessed using HTTP protocol and thats why we mostly
extend HttpServlet class. Servlet API hierarchy is shown in below image.

Q2. What are the differences between Get and Post methods?
Get Post
Limited amount of data can be sent because data is Large amount of data can be sent because data is
sent in header. sent in body.
Not Secured because data is exposed in URL bar. Secured because data is not exposed in URL bar.
Can be bookmarked Cannot be bookmarked
Idempotent Non-Idempotent
It is more efficient and used than Post It is less efficient and used

Q3. What is Request Dispatcher?

RequestDispatcher interface is used to forward the request to another resource that can be HTML, JSP
or another servlet in same application. We can also use this to include the content of another resource
to the response.
There are two methods defined in this interface:
1.void forward()
2.void include()

Q4. What are the differences between forward() method and

sendRedirect() methods?

forward() method SendRedirect() method

forward() sends the same request to sendRedirect() method sends new request always because it
another resource. uses the URL bar of the browser.
forward() method works at server sendRedirect() method works at client side.
side.
forward() method works within the sendRedirect() method works within and outside the server.
server only.

Q5. What is the life-cycle of a servlet?

There are 5 stages in the lifecycle of a servlet:

1. Servlet is loaded
2. Servlet is instantiated
3. Servlet is initialized
4. Service the request
5. Servlet is destroyed
Q6. How does cookies work in Servlets?
• Cookies are text data sent by server to the client and it gets saved at the client local machine.
• Servlet API provides cookies support through javax.servlet.http.Cookie class that implements
Serializable and Cloneable interfaces.
• HttpServletRequest getCookies() method is provided to get the array of Cookies from request,
since there is no point of adding Cookie to request, there are no methods to set or add cookie to
request.
• Similarly HttpServletResponse addCookie(Cookie c) method is provided to attach cookie in
response header, there are no getter methods for cookie.
Q7. What are the differences between ServletContext vs
ServletConfig?
The difference between ServletContext and ServletConfig in Servlets JSP is in below tabular format.
ServletConfig ServletContext
Servlet config object represent single servlet It represent whole web application running on
particular JVM and common for all the servlet
Its like local parameter associated with Its like global parameter associated with whole
particular servlet application
It’s a name value pair defined inside the servlet ServletContext has application wide scope so define
section of web.xml file so it has servlet wide outside of servlet tag in web.xml file.
scope
getServletConfig() method is used to get the getServletContext() method is used to get the
config object context object.
for example shopping cart of a user is a specific To get the MIME type of a file or application session
to particular user so here we can use servlet related information is stored using servlet context
config object.

Q8. What are the different methods of session management in

servlets?
Session is a conversational state between client and server and it can consists of multiple request and
response between client and server. Since HTTP and Web Server both are stateless, the only way to
maintain a session is when some unique information about the session (session id) is passed between
server and client in every request and response.
Some of the common ways of session management in servlets are:
1. User Authentication
2. HTML Hidden Field
3. Cookies
4. URL Rewriting
5. Session Management API
 Apart from this blog, if you want to get trained by professionals on this technology, you can opt for
structured training from edureka! Click below to know more.
JDBC – Java Interview Questions
1. What is JDBC Driver?
JDBC Driver is a software component that enables java application to interact with the database. There
are 4 types of JDBC drivers:
1. JDBC-ODBC bridge driver
2. Native-API driver (partially java driver)
3. Network Protocol driver (fully java driver)
4. Thin driver (fully java driver)

2. What are the steps to connect to a database in java?

• Registering the driver class
• Creating connection
• Creating statement
• Executing queries
• Closing connection
3. What are the JDBC API components?
The java.sql package contains interfaces and classes for JDBC API.
Interfaces:
• Connection
• Statement
• PreparedStatement
• ResultSet
• ResultSetMetaData
• DatabaseMetaData
• CallableStatement etc.
Classes:
• DriverManager
• Blob
• Clob
• Types
• SQLException etc.
4. What is the role of JDBC DriverManager class?
The DriverManager class manages the registered drivers. It can be used to register and unregister
drivers. It provides factory method that returns the instance of Connection.
5. What is JDBC Connection interface?
The Connection interface maintains a session with the database. It can be used for transaction
management. It provides factory methods that returns the instance of Statement, PreparedStatement,
CallableStatement and DatabaseMetaData.

In case you are facing any challenges with these java interview questions, please comment on your
problems in the section below.
6. What is the purpose of JDBC ResultSet interface?
The ResultSet object represents a row of a table. It can be used to change the cursor pointer and get the
information from the database.
7. What is JDBC ResultSetMetaData interface?
The ResultSetMetaData interface returns the information of table such as total number of columns,
column name, column type etc.
8. What is JDBC DatabaseMetaData interface?
The DatabaseMetaData interface returns the information of the database such as username, driver
name, driver version, number of tables, number of views etc.
9. What do you mean by batch processing in JDBC?
Batch processing helps you to group related SQL statements into a batch and execute them instead of
executing a single query. By using batch processing technique in JDBC, you can execute multiple queries
which makes the performance faster.
10. What is the difference between execute, executeQuery,
executeUpdate?
Statement execute(String query) is used to execute any SQL query and it returns TRUE if the result is an
ResultSet such as running Select queries. The output is FALSE when there is no ResultSet object such as
running Insert or Update queries. We can use getResultSet() to get the ResultSet and getUpdateCount()
method to retrieve the update count.
Statement executeQuery(String query) is used to execute Select queries and returns the ResultSet.
ResultSet returned is never null even if there are no records matching the query. When executing select
queries we should use executeQuery method so that if someone tries to execute insert/update
statement it will throw java.sql.SQLException with message “executeQuery method can not be used for
update”.
Statement executeUpdate(String query) is used to execute Insert/Update/Delete (DML) statements or
DDL statements that returns nothing. The output is int and equals to the row count for SQL Data
Manipulation Language (DML) statements. For DDL statements, the output is 0.
You should use execute() method only when you are not sure about the type of statement else use
executeQuery or executeUpdate method.
Q11. What do you understand by JDBC Statements?
JDBC statements are basically the statements which are used to send SQL commands to the database
and retrieve data back from the database. Various methods like execute(), executeUpdate(),
executeQuery, etc. are provided by JDBC to interact with the database.
JDBC supports 3 types of statements:
1. Statement: Used for general purpose access to the database and executes a static SQL query at
runtime.
2. PreparedStatement: Used to provide input parameters to the query during execution.
3. CallableStatement: Used to access the database stored procedures and helps in accepting runtime
parameters.
In case you are facing any challenges with these java interview questions, please comment your
problems in the section below. Apart from this Java Interview Questions Blog, if you want to get trained
from professionals on this technology, you can opt for a structured training from edureka!
Spring Framework – Java Interview Questions
Q1. What is Spring?
Wikipedia defines the Spring framework as “an application framework and inversion of control container
for the Java platform. The framework’s core features can be used by any Java application, but there are
extensions for building web applications on top of the Java EE platform.” Spring is essentially a
lightweight, integrated framework that can be used for developing enterprise applications in java.
Q2. Name the different modules of the Spring framework.
Some of the important Spring Framework modules are:
• Spring Context – for dependency injection.
• Spring AOP – for aspect oriented programming.
• Spring DAO – for database operations using DAO pattern
• Spring JDBC – for JDBC and DataSource support.
• Spring ORM – for ORM tools support such as Hibernate
• Spring Web Module – for creating web applications.
• Spring MVC – Model-View-Controller implementation for creating web applications, web services
etc.
Q3. List some of the important annotations in annotation-based
Spring configuration.
The important annotations are:
• @Required
• @Autowired
• @Qualifier
• @Resource
• @PostConstruct
• @PreDestroy
Q4. Explain Bean in Spring and List the different Scopes of Spring
bean.
Beans are objects that form the backbone of a Spring application. They are managed by the Spring IoC
container. In other words, a bean is an object that is instantiated, assembled, and managed by a Spring
IoC container.
There are five Scopes defined in Spring beans.

• Singleton: Only one instance of the bean will be created for each container. This is the default
scope for the spring beans. While using this scope, make sure spring bean doesn’t have shared
instance variables otherwise it might lead to data inconsistency issues because it’s not thread-
safe.
• Prototype: A new instance will be created every time the bean is requested.
• Request: This is same as prototype scope, however it’s meant to be used for web applications. A
new instance of the bean will be created for each HTTP request.
• Session: A new bean will be created for each HTTP session by the container.
• Global-session: This is used to create global session beans for Portlet applications.
In case you are facing any challenges with these java interview questions, please comment on your
problems in the section below.
Q5. Explain the role of DispatcherServlet and ContextLoaderListener.
DispatcherServlet is basically the front controller in the Spring MVC application as it loads the spring
bean configuration file and initializes all the beans that have been configured. If annotations are
enabled, it also scans the packages to configure any bean annotated with @Component, @Controller,
@Repository or @Service annotations.

ContextLoaderListener, on the other hand, is the listener to start up and shut down the
WebApplicationContext in Spring root. Some of its important functions includes tying up the lifecycle of
Application Context to the lifecycle of the ServletContext and automating the creation of
ApplicationContext.

Q6. What are the differences between constructor injection and

setter injection?
No. Constructor Injection Setter Injection
1) No Partial Injection Partial Injection
2) Doesn’t override the setter property Overrides the constructor property if both are
defined.
3) Creates a new instance if any Doesn’t create a new instance if you change the
modification occurs property value
4) Better for too many properties Better for a few properties.

Q7. What is autowiring in Spring? What are the autowiring modes?

Autowiring enables the programmer to inject the bean automatically. We don’t need to write explicit
injection logic. Let’s see the code to inject bean using dependency injection.
1. <bean id=“emp”class=“com.javatpoint.Employee” autowire=“byName” />
The autowiring modes are given below:
No. Mode Description
1) no this is the default mode, it means autowiring is not enabled.
2) byName Injects the bean based on the property name. It uses setter method.
3) byType Injects the bean based on the property type. It uses setter method.
4) constructor It injects the bean using constructor

Q8. How to handle exceptions in Spring MVC Framework?

Spring MVC Framework provides the following ways to help us achieving robust exception handling.
Controller Based:
We can define exception handler methods in our controller classes. All we need is to annotate these
methods with @ExceptionHandler annotation.
Global Exception Handler:
Exception Handling is a cross-cutting concern and Spring provides @ControllerAdvice annotation that
we can use with any class to define our global exception handler.
HandlerExceptionResolver implementation:
For generic exceptions, most of the times we serve static pages. Spring Framework provides
HandlerExceptionResolver interface that we can implement to create global exception handler. The
reason behind this additional way to define global exception handler is that Spring framework also
provides default implementation classes that we can define in our spring bean configuration file to get
spring framework exception handling benefits.
Q9. What are some of the important Spring annotations which you
have used?
Some of the Spring annotations that I have used in my project are:
@Controller – for controller classes in Spring MVC project.
@RequestMapping – for configuring URI mapping in controller handler methods. This is a very
important annotation, so you should go through Spring MVC RequestMapping Annotation Examples
@ResponseBody – for sending Object as response, usually for sending XML or JSON data as response.
@PathVariable – for mapping dynamic values from the URI to handler method arguments.
@Autowired – for autowiring dependencies in spring beans.
@Qualifier – with @Autowired annotation to avoid confusion when multiple instances of bean type is
present.
@Service – for service classes.
@Scope – for configuring the scope of the spring bean.
@Configuration, @ComponentScan and @Bean – for java based configurations.
AspectJ annotations for configuring aspects and advices , @Aspect, @Before, @After, @Around,
@Pointcut, etc.
Q10. How to integrate Spring and Hibernate Frameworks?
We can use Spring ORM module to integrate Spring and Hibernate frameworks if you are using
Hibernate 3+ where SessionFactory provides current session, then you should avoid using
HibernateTemplate or HibernateDaoSupport classes and better to use DAO pattern with dependency
injection for the integration.
Also, Spring ORM provides support for using Spring declarative transaction management, so you should
utilize that rather than going for hibernate boiler-plate code for transaction management.
Q11. Name the types of transaction management that Spring
supports.
Two types of transaction management are supported by Spring. They are:
1. Programmatic transaction management: In this, the transaction is managed with the help of
programming. It provides you extreme flexibility, but it is very difficult to maintain.
2. Declarative transaction management: In this, transaction management is separated from the
business code. Only annotations or XML based configurations are used to manage the
transactions.
Apart from these Core Java interview questions for experienced professionals, if you want to get trained
by professionals on this technology, you can opt for a structured training from edureka!
Hibernate – Java Interview Questions for Experienced
Professionals
1. What is Hibernate Framework?
Object-relational mapping or ORM is the programming technique to map application domain model
objects to the relational database tables. Hibernate is Java-based ORM tool that provides a framework
for mapping application domain objects to the relational database tables and vice versa.
Hibernate provides a reference implementation of Java Persistence API, that makes it a great choice as
ORM tool with benefits of loose coupling. We can use the Hibernate persistence API for CRUD
operations. Hibernate framework provide option to map plain old java objects to traditional database
tables with the use of JPA annotations as well as XML based configuration.
Similarly, hibernate configurations are flexible and can be done from XML configuration file as well as
programmatically.
2. What are the important benefits of using Hibernate Framework?
Some of the important benefits of using hibernate framework are:
1. Hibernate eliminates all the boiler-plate code that comes with JDBC and takes care of managing
resources, so we can focus on business logic.
2. Hibernate framework provides support for XML as well as JPA annotations, that makes our code
implementation independent.
3. Hibernate provides a powerful query language (HQL) that is similar to SQL. However, HQL is fully
object-oriented and understands concepts like inheritance, polymorphism, and association.
4. Hibernate is an open source project from Red Hat Community and used worldwide. This makes it a
better choice than others because learning curve is small and there are tons of online
documentation and help is easily available in forums.
5. Hibernate is easy to integrate with other Java EE frameworks, it’s so popular that Spring
Framework provides built-in support for integrating hibernate with Spring applications.
6. Hibernate supports lazy initialization using proxy objects and perform actual database queries only
when it’s required.
7. Hibernate cache helps us in getting better performance.
8. For database vendor specific feature, hibernate is suitable because we can also execute native sql
queries.
Overall hibernate is the best choice in current market for ORM tool, it contains all the features that you
will ever need in an ORM tool.
3. Explain Hibernate architecture.
Hibernate has a layered architecture which helps the user to operate without having to know the
underlying APIs. Hibernate makes use of the database and configuration data to provide persistence
services (and persistent objects) to the application. It includes many objects such as persistent object,
session factory, transaction factory, connection factory, session, transaction etc.

The Hibernate architecture is categorized in four layers.

• Java application layer
• Hibernate framework layer
• Backhand API layer
• Database layer
4. What are the differences between get and load methods?
The differences between get() and load() methods are given below.
No. get() load()
1) Returns null if object is not found. Throws ObjectNotFoundException if an
object is not found.
2) get() method always hit the database. load() method doesn’t hit the database.
3) It returns a real object, not a proxy. It returns a proxy object.
4) It should be used if you are not sure about the It should be used if you are sure that the
existence of instance. instance exists.

5. What are the advantages of Hibernate over JDBC?

Some of the important advantages of Hibernate framework over JDBC are:
1. Hibernate removes a lot of boiler-plate code that comes with JDBC API, the code looks cleaner and
readable.
2. Hibernate supports inheritance, associations, and collections. These features are not present with
JDBC API.
3. Hibernate implicitly provides transaction management, in fact, most of the queries can’t be
executed outside transaction. In JDBC API, we need to write code for transaction management
using commit and rollback.
4. JDBC API throws SQLException that is a checked exception, so we need to write a lot of try-catch
block code. Most of the times it’s redundant in every JDBC call and used for transaction
management. Hibernate wraps JDBC exceptions and throw JDBCException or HibernateException
un-checked exception, so we don’t need to write code to handle it. Hibernate built-in transaction
management removes the usage of try-catch blocks.
5. Hibernate Query Language (HQL) is more object-oriented and close to Java programming
language. For JDBC, we need to write native SQL queries.
6. Hibernate supports caching that is better for performance, JDBC queries are not cached hence
performance is low.
7. Hibernate provides option through which we can create database tables too, for JDBC tables must
exist in the database.
8. Hibernate configuration helps us in using JDBC like connection as well as JNDI DataSource for the
connection pool. This is a very important feature in enterprise application and completely missing
in JDBC API.
9. Hibernate supports JPA annotations, so the code is independent of the implementation and easily
replaceable with other ORM tools. JDBC code is very tightly coupled with the application.
In case you are facing any challenges with these Java interview questions, please comment on your
problems in the section below. Apart from this Java Interview Questions Blog, if you want to get trained
from professionals on this technology, you can opt for structured training from edureka!
JSP – Java Interview Questions
1. What are the life-cycle methods for a jsp?
Methods Description
public void jspInit() It is invoked only once, same as init
method of servlet.
public void _jspService(ServletRequest It is invoked at each request, same as
request,ServletResponse)throws service() method of servlet.
ServletException,IOException
public void jspDestroy() It is invoked only once, same as
destroy() method of servlet.

2. What are the JSP implicit objects?

JSP provides 9 implicit objects by default. They are as follows:
Object Type
1) out JspWriter
2) request HttpServletRequest
3) response HttpServletResponse
4) config ServletConfig
5) session HttpSession
6) application ServletContext
7) pageContext PageContext
8) page Object
9) exception Throwable

3. What are the differences between include directive and include

action?
include directive include action
The include directive includes the content at The include action includes the content at request
page translation time. time.
The include directive includes the original The include action doesn’t include the original content
content of the page so page size increases at rather invokes the include() method of Vendor
runtime. provided class.
It’s better for static pages. It’s better for dynamic pages.

4. How to disable caching on back button of the browser?

<%
response.setHeader(“Cache-Control”,”no-store”);
response.setHeader(“Pragma”,”no-cache”);
response.setHeader (“Expires”, “0”); //prevents caching at the proxy server
%>
5. What are the different tags provided in JSTL?
There are 5 type of JSTL tags.
1. core tags
2. sql tags
3. xml tags
4. internationalization tags
5. functions tags
6. How to disable session in JSP?
1. <%@ page session=“false” %>
7. How to delete a Cookie in a JSP?
The following code explains how to delete a Cookie in a JSP :
1 Cookie mycook = new Cookie("name1","value1");
2
3 response.addCookie(mycook1);
4
5 Cookie killmycook = new Cookie("mycook1","value1");
6
7 killmycook . set MaxAge ( 0 );
8
9 killmycook . set Path ("/");
10
11 killmycook . addCookie ( killmycook 1 );

8. Explain the jspDestroy() method.

jspDestry() method is invoked from javax.servlet.jsp.JspPageinterface whenever a JSP page is about to
be destroyed. Servlets destroy methods can be easily overridden to perform cleanup, like when closing a
database connection.
9. How is JSP better than Servlet technology?
JSP is a technology on the server’s side to make content generation simple. They are document-centric,
whereas servlets are programs. A Java server page can contain fragments of Java program, which
execute and instantiate Java classes. However, they occur inside an HTML template file. It provides the
framework for the development of a Web Application.
10. Why should we not configure JSP standard tags in web.xml?
We don’t need to configure JSP standard tags in web.xml because when container loads the web
application and find TLD files, it automatically configures them to be used directly in the application JSP
pages. We just need to include it in the JSP page using taglib directive.
11. How will you use JSP EL in order to get the HTTP method name?
Using pageContext JSP EL implicit object you can get the request object reference and make use of the
dot operator to retrieve the HTTP method name in the JSP page. The JSP EL code for this purpose will
look like ${pageContext.request.method}.
In case you are facing any challenges with these java interview questions, please comment on your
problems in the section below. Apart from this Java Interview Questions Blog, if you want to get trained
from professionals on this technology, you can opt for structured training from edureka!
Exception and Thread Java Interview Questions
Q1. What is the difference between Error and Exception?
An error is an irrecoverable condition occurring at runtime. Such as OutOfMemory error. These JVM
errors you cannot repair them at runtime. Though error can be caught in the catch block but the
execution of application will come to a halt and is not recoverable.
While exceptions are conditions that occur because of bad input or human error etc. e.g.
FileNotFoundException will be thrown if the specified file does not exist. Or a NullPointerException will
take place if you try using a null reference. In most of the cases it is possible to recover from an
exception (probably by giving the user feedback for entering proper values etc.
Q2. How can you handle Java exceptions?
There are five keywords used to handle exceptions in Java:
1. try
2. catch
3. finally
4. throw
5. throws
Q3. What are the differences between Checked Exception and
Unchecked Exception?
Checked Exception
• The classes that extend Throwable class except RuntimeException and Error are known as checked
exceptions.
• Checked exceptions are checked at compile-time.
• Example: IOException, SQLException etc.
Unchecked Exception
• The classes that extend RuntimeException are known as unchecked exceptions.
• Unchecked exceptions are not checked at compile-time.
• Example: ArithmeticException, NullPointerException etc.
Q4. What are the different ways of thread usage?
There are two ways to create a thread:
• Extending Thread class
This creates a thread by creating an instance of a new class that extends the Thread class. The extending
class must override the run() function, which is the thread’s entry point.
• Implementing Runnable interface
This is the easiest way to create a thread, by creating a class that implements the runnable interface.
After implementing the runnable interface, the class must implement the public void run() method ()
The run() method creates a parallel thread in your programme. When run() returns, the thread will
come to an end.
The run() method creates a parallel thread in your programme. When run() returns, the thread will
come to an end.
Within the run() method, you must specify the thread’s code.
Like any other method, the run() method can call other methods, use other classes, and define variables.
Java works as “pass by value” or “pass by reference” phenomenon?
Java is always pass-by-value. This means that it creates a copy of the contents of the parameter in
memory. In Java, object variables always refer to the memory heap’s real object.
Q5. Will the finally block get executed when the return statement is
written at the end of try block and catch block as shown below?
The finally block always gets executed even hen the return statement is written at the end of the try
block and the catch block. It always executes , whether there is an exception or not. There are only a few
situations in which the finally block does not execute, such as VM crash, power failure, software crash,
etc. If you don’t want to execute the finally block, you need to call the System.exit() method explicitly in
the finally block.

Q6. How does an exception propagate in the code?

If an exception is not caught, it is thrown from the top of the stack and falls down the call stack to the
previous procedure. If the exception isn’t caught there, it falls back to the previous function, and so on,
until it’s caught or the call stack reaches the bottom. The term for this is Exception propagation.

Q7. Can you explain the Java thread lifecycle?

The java thread lifecycle has the following states-
New-
When a thread is created, and before the program starts the thread, it is in the new state. It is also
referred to as a born thread.
Runnable
When a thread is started, it is in the Runnable state. In this state, the thread is executing its task.
Waiting
Sometimes, a thread goes to the waiting state, where it remains idle because another thread is
executing. When the other thread has finished, the waiting thread again comes into the running state.
Timed Waiting
In timed waiting, the thread goes to waiting state. But, it remains in waiting state for only a specified
interval of time after which it starts executing.It remains waiting either till the time interval ends or till
the other thread has finished.
Terminated
A thread is said to be in this state once it terminates. It may be because the thread has completed its
task or due to any other reason.
Q8. What purpose do the keywords final, finally, and finalize fulfill?
Final:
Final is used to apply restrictions on class, method, and variable. A final class can’t be inherited, final
method can’t be overridden and final variable value can’t be changed. Let’s take a look at the example
below to understand it better.
1 class FinalVarExample {
2 public static void main( String args[])
3 {
4 final int a=10; // Final variable
5 a=50; //Error as value can't be changed
6 }
Finally
Finally is used to place important code, it will be executed whether the exception is handled or not. Let’s
take a look at the example below to understand it better.
1 class FinallyExample {
2 public static void main(String args[]){
3 try {
4 int x=100;
5 }
6 catch(Exception e) {
7 System.out.println(e);
8 }
9 finally {
10 System.out.println("finally block is executing");}
11 }}
12 }
Finalize
Finalize is used to perform clean up processing just before the object is garbage collected. Let’s take a
look at the example below to understand it better.
1 class FinalizeExample {
2 public void finalize() {
3 System.out.println("Finalize is called");
4 }
5 public static void main(String args[])
6 {
7 FinalizeExample f1=new FinalizeExample();
8 FinalizeExample f2=new FinalizeExample();
9 f1= NULL;
10 f2=NULL;
11 System.gc();
12 }
13 }

Q9. What are the differences between throw and throws?

throw keyword throws keyword
Throw is used to explicitly throw an Throws is used to declare an exception.
exception.
Checked exceptions can not be Checked exception can be propagated with throws.
propagated with throw only.
Throw is followed by an instance. Throws is followed by class.
Throw is used within the method. Throws is used with the method signature.
You cannot throw multiple exception You can declare multiple exception e.g. public void method()
throws IOException,SQLException.
In case you are facing any challenges with these java interview questions, please comment on your
problems in the section below.
Q10. What is exception hierarchy in java?
The hierarchy is as follows:
Throwable is a parent class of all Exception classes. There are two types of Exceptions: Checked
exceptions and UncheckedExceptions or RunTimeExceptions. Both type of exceptions extends Exception
class whereas errors are further classified into Virtual Machine error and Assertion error.

Q11. How to create a custom Exception?

To create you own exception extend the Exception class or any of its subclasses.
• class New1Exception extends Exception { } // this will create Checked Exception
• class NewException extends IOException { } // this will create Checked exception
• class NewException extends NullPonterExcpetion { } // this will create UnChecked exception
Q12. What are the important methods of Java Exception Class?
Exception and all of it’s subclasses doesn’t provide any specific methods and all of the methods are
defined in the base class Throwable.
1. String getMessage() – This method returns the message String of Throwable and the message can
be provided while creating the exception through it’s constructor.
2. String getLocalizedMessage() – This method is provided so that subclasses can override it to
provide locale specific message to the calling program. Throwable class implementation of this
method simply use getMessage() method to return the exception message.
3. Synchronized Throwable getCause() – This method returns the cause of the exception or null id
the cause is unknown.
4. String toString() – This method returns the information about Throwable in String format, the
returned String contains the name of Throwable class and localized message.
5. void printStackTrace() – This method prints the stack trace information to the standard error
stream, this method is overloaded and we can pass PrintStream or PrintWriter as an argument to
write the stack trace information to the file or stream.
Q13. What are the differences between processes and threads?
Process Thread
Definition An executing instance of a program is called A thread is a subset of the process.
 a process.
Communic Processes must use inter-process Threads can directly communicate with
ation communication to communicate with other threads of its process.
sibling processes.
Control Processes can only exercise control over Threads can exercise considerable control
child processes. over threads of the same process.
Changes Any change in the parent process does not Any change in the main thread may affect
affect child processes. the behavior of the other threads of the
process.
Memory Run in separate memory spaces. Run in shared memory spaces.
Controlled Process is controlled by the operating Threads are controlled by programmer in a
by system. program.
Dependenc Processes are independent. Threads are dependent.
e

Q14. What is a finally block? Is there a case when finally will not
execute?
Finally block is a block which always executes a set of statements. It is always associated with a try block
regardless of any exception that occurs or not.
Yes, finally will not be executed if the program exits either by calling System.exit() or by causing a fatal
error that causes the process to abort.
Q15. What is synchronization?
Synchronization refers to multi-threading. A synchronized block of code can be executed by only one
thread at a time. As Java supports execution of multiple threads, two or more threads may access the
same fields or objects. Synchronization is a process which keeps all concurrent threads in execution to
be in sync. Synchronization avoids memory consistency errors caused due to inconsistent view of shared
memory. When a method is declared as synchronized the thread holds the monitor for that method’s
object. If another thread is executing the synchronized method the thread is blocked until that thread
releases the monitor.

Q16. Can we write multiple catch blocks under single try block?
Yes we can have multiple catch blocks under single try block but the approach should be from specific to
general. Let’s understand this with a programmatic example.
1 public class Example {
2 public static void main(String args[]) {
3 try {
4 int a[]= new int[10];
5 a[10]= 10/0;
6 }
7 catch(ArithmeticException e)
8 {
9 System.out.println("Arithmetic exception in first catch block");
10 }
11 catch(ArrayIndexOutOfBoundsException e)
12 {
13 System.out.println("Array index out of bounds in second catch block");
14 }
15 catch(Exception e)
16 {
17 System.out.println("Any exception in third catch block");
18 }
19 }
Q17. What are the important methods of Java Exception Class?
Methods are defined in the base class Throwable. Some of the important methods of Java exception
class are stated below.
1. String getMessage() – This method returns the message String about the exception. The message
can be provided through its constructor.
2. public StackTraceElement[] getStackTrace() – This method returns an array containing each
element on the stack trace. The element at index 0 represents the top of the call stack whereas
the last element in the array represents the method at the bottom of the call stack.
3. Synchronized Throwable getCause() – This method returns the cause of the exception or null id as
represented by a Throwable object.
4. String toString() – This method returns the information in String format. The returned String
contains the name of Throwable class and localized message.
5. void printStackTrace() – This method prints the stack trace information to the standard error
stream.
Q18. What is OutOfMemoryError in Java?
OutOfMemoryError is the subclass of java.lang.Error which generally occurs when our JVM runs out of
memory.
Q19. What is a Thread?
A thread is the smallest piece of programmed instructions which can be executed independently by a
scheduler. In Java, all the programs will have at least one thread which is known as the main thread. This
main thread is created by the JVM when the program starts its execution. The main thread is used to
invoke the main() of the program.
Q20. What are the two ways to create a thread?
In Java, threads can be created in the following two ways:-
• By implementing the Runnable interface.
• By extending the Thread
Q21. What are the different types of garbage collectors in Java?
Garbage collection in Java a program which helps in implicit memory management. Since in Java, using
the new keyword you can create objects dynamically, which once created will consume some memory.
Once the job is done and there are no more references left to the object, Java using garbage collection
destroys the object and relieves the memory occupied by it. Java provides four types of garbage
collectors:
• Serial Garbage Collector
• Parallel Garbage Collector
• CMS Garbage Collector
• G1 Garbage Collector

From <https://www.edureka.co/blog/interview-questions/java-interview-questions/>
Sunday, March 13, 2022 9:57 PM
Thursday, February 10, 2022 5:42 PM