Most Tricky Java Interview Questions - Part 1

 

Java is one of the most popular programming language in today's world and thus learning it to a great extent can be a huge asset for anyone. Therefore I have brought an extensive list of some of the most tricky Java interview questions that will surely set you apart whether you are preparing for your technical interview or are a Java enthusiast.

So let's get started with our exquisite list of the most tricky Java interview question.

 

1. What is Garbage collection in java?

In languages like C and C++ where  programmer is responsible for both creation and destruction of objects, usually the programmer neglects the destruction of objects . Due to this negligence, at certain point the memory may get exhausted and sufficient memory may not be available for creation of new objects causing entire program to terminate abnormally.
But in Java, the programmer need not to care for destroying objects explicitly. Garbage Collector is used to free heap memory by destroying unreachable objects automatically by itself without the programmer needing to worry about it.
Unreachable objects : An object is said to be unreachable if and only if it doesn’t contain any reference to it in the program (direct or indirect).

Note : An object is only eligible for garbage collection, if and only if it is unreachable. 

Example :

CodingWithArt obj = new CodingWithArt(); // object is reachable via the reference in 'obj' 
obj = null;  // the CodingWithArt object is unreachable now.   

In the above example there is no reference to obj and therefore it is eligible for garbage collection. It is recommended to make an object unreachable if it is not required so that it's memory can be utilized somewhere else. 

Requesting JVM to run Garbage Collector 

Garbage collector can not be invoked by programmer directly. If you have made an object eligible for garbage collection, you don't know when the garbage collector will be invoked. You have to wait for JVM to run the memory cleanup program that performs garbage collection. But we can request the JVM to invoke the garbage collector using System.gc() method. The System class contain static method gc() for requesting JVM to run Garbage Collector. 

 

2. Explain mark and sweep algorithm for garbage collection. 

To determine which objects are no longer in use, the JVM intermittently runs what is called as mark-and-sweep algorithm.

Mark and Sweep Algorithm operates in two phases: Mark phase and Sweep phase 

1.) Mark Phase 

When an object is created, its mark bit is set to 0 (false). Now in the Mark phase, we set the marked bit for all the reachable objects (which have a direct or indirect reference) to 1 (true). This can be performed by using a graph traversal algorithm such as depth first search and breadth first search. Any object in the program is a node and an edge represents an object referring another object. 

 DFS Algorithm - Mark phase:

MarkPhase(root)
{
    If marked(root) == false then
        marked(root) = true
        For each obj referenced by root
            MarkPhase(obj)
}

In the above program, root is a directly accessible variable that refer to an object. 

 2. Sweep Phase 

In this phase all the unreachable objects are actually cleared from the heap memory. All the objects on the heap memory are accessed one by one : 

a. if mark bit is false, means it is unreachable so its memory is cleared from heap. 

b. if mark bit is true, means it is reachable and thus we just unset its marked bit (0) for future use.


SweepPhase()
{
For each object obj in heap
    If marked(obj) == true then
        marked(obj) = false
    else
        heap.release(obj)
}
 
Garbage collection process by diagrams :

a) All the objects have their marked bits set to false. 



b) Reachable objects are marked true

        

c) Non reachable objects are cleared from the heap. 



 

 3. What is the difference between checked exception and unchecked exception.


There are two types of exceptions in Java: checked exception and unchecked exception.

1. Checked Exception :

In simple terms, checked exceptions are checked at compile-time.Therefore if a method is capable of causing an exception, then it must either handle it using try-catch block otherwise it must specify it using 'throws' keyword so that the caller of the method can guard itself from the exception.

Examples : ClassNotFoundException, SQLException, IOException

class CodingWithArt { 
	void func() throws IOException { 
		FileReader file = new FileReader("C:\\folder\\test.txt"); 
		BufferedReader fileInput = new BufferedReader(file); 

		System.out.println(fileInput.readLine()); 		
		fileInput.close(); 
	} 
} 

Since IOExceptionn is a checked exception therefore we have to use throws keyword with the func() function otherwise we will get a compile time error.

2. Unchecked exception :

Unchecked exceptions are not checked at compile time. It means if your program is throwing an unchecked exception and even if you didn’t handle that exception, the program won’t give a compilation error. It is the programmer's duty to judge the conditions in advance, that can cause such exceptions and handle them appropriately otherwise this may result in errors. 

Examples : NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException

In Java, all exceptions under Error and RuntimeException classes are unchecked exceptions, everything else under throwable is checked.

 

4. Differentiate between  JDK , JRE and JVM .

JDK (Java Development Kit):

The Java Development Kit (JDK) is a software development environment used for developing Java applications and applets. It includes the Java Runtime Environment (JRE), a compiler (javac), an archiver (jar),  and other development tools needed in Java. JDK helps Java developers to code and run Java programs. It can be installed on Windows, Unix, and Mac operating systems.

JRE (Java Runtime Envirroment):

The Java Runtime Environment (JRE) provides the minimum requirements for executing a Java application; it consists of the Java Virtual Machine (JVM), class libraries, and supporting files.
It uses important package classes like math, swingetc, util, lang, awt, and runtime libraries.

JVM (Java Virtual Machine) : 

Java Virtual Machine (JVM) is an engine that provides a runtime environment to drive the Java Code or applications. Whatever Java program you run using JRE or JDK goes into JVM and JVM is responsible for executing the java program line by line hence it is also known as interpreter.

JDK vs JRE vs JVM


5. What is the difference between StringBuffer and StringBuilder in Java.


String class is immutable (cannot be modified) in Java, therefore whenever String manipulations are performed, automatically a new String would be generated by discarding the older one. To avoid garbage in heap, Java came up with StringBuffer and StringBuilder.

sSringBuffer and StringBuffer both are mutable classes in java, i.e they allow the stored string to be modified.

Differences between StringBuffer and StringBuilder :



6. What is multithreading ? How can we create thread in java?


A thread is a lightweight sub-process, the smallest unit of processing. Multithreading is a Java feature that allows concurrent execution of two or more parts of a program for maximum utilization of CPU. We can create multiple threads in a program which can simultaneously perofrm their operations.

Threads can be created by using two mechanisms :
1. Extending the Thread class
2. Implementing the Runnable Interface

1. Extending the Thread class


We create a class that extends the java.lang.Thread class. We have to override the run() method available in the Thread class. A thread begins its life inside run() method. We create an object of our new class and call start() method to start the execution of a thread. start() invokes the run() method on the Thread object.

// Java code for thread creation by extending the Thread class 
class CodingWithArt extends Thread 
{ 
	public void run() 
	{ 
		try
		{ 
			// Displaying the running thread 
			System.out.println ("Thread " + Thread.currentThread().getId() + " is running");

		} 
		catch (Exception e) 
		{ 
			// Throwing an exception 
			System.out.println ("Exception caught"); 
		} 
	} 
} 

// Main Class 
public class Multithread 
{ 
	public static void main(String[] args) 
	{ 
		int n = 2; // Number of threads 
		for (int i=0; i!=n; i++) 
		{ 
			CodingWithArt object = new CodingWithArt(); 
			object.start(); 
		} 
	} 
} 


2. Implementing the Runnable Interface

 Create a new class which implements java.lang.Runnable interface and overrides run() method. Then we instantiate a Thread object and call start() method on this object.

// Java code for thread creation by implementing 
// the Runnable Interface 
class CodingWithArt implements Runnable 
{ 
	public void run() 
	{ 
		try
		{ 
			// Displaying the running thread
			System.out.println ("Thread " + Thread.currentThread().getId() + " is running"); 

		} 
		catch (Exception e) 
		{ 
			// Throwing an exception 
			System.out.println ("Exception caught"); 
		} 
	} 
} 

// Main Class 
class Multithread 
{ 
	public static void main(String[] args) 
	{ 
		int n = 2; // Number of threads 
		for (int i=0; i!=n; i++) 
		{ 
			Thread object = new Thread(new CodingWithArt()); 
			object.start(); 
		} 
	} 
} 


Thread Class vs Runnable Interface


Generally both Thread and Runnable are equally effective in creating threads. But since Java does not support multiple inheritance, the class which inherits Thread class cannot inherit any other class. This can be a disadvantage in some situations. This problem does not arise when implementing the Runnable interface, because a class can implement multiple interfaces together and can also extend a class and interface together.    

This brings us to the end of Part-1 of this series. Also check out the other part in the same series to find more challenging Java interview questions :

 
Thank you for your patience reading. If you enjoyed this post, I’d be very grateful if you’d help it spread by emailing it to a friend, or sharing it on Whatsapp or Facebook.  
  
Happy learning!!