The ultimate guide to Java interviews with 300+ real-world questions and answers. Get interview-ready in just a few hours with strategies developed by FAANG engineers.

It’s very common to have interviews testing your knowledge of a programming language you claim to be an expert in.

If you've got an interview coming up on Java soon and need to get up to speed, this is the ideal course for you. You'll refresh your memory on everything from the basics to more advanced functionality you’re likely to be asked about. Even if you're using Java every day, you may not have been exposed to parts of it in some time, so it's always useful to make sure you're updated.

This course features more than 300 of the most commonly asked core Java interview questions that you're likely to face as an experienced software engineer. You'll get to explore questions by topic, as well as see detailed answers for each one, and plenty of live code examples where relevant. Get started today.

The Java Interview Handbook: 300+ Interview Questions

<div class="card">
 # Notes
 <div class="ans">

<table>
<tr><th>Pattern</th><th>Purpose</th></tr>
<tr><td>Prototype Pattern</td><td>Prototype pattern involves creating new objects by copying existing objects. The object whose copies are made is called the prototype. In Java the <code class="mthd">clone()</code> method of <code class="abtc">java.lang.Object</code> is an example of this pattern.



</td>
</tr>

<tr><td>Factory Method Pattern</td><td>The factory method is defined as providing an interface for object creation but delegating the actual instantiation of objects to subclasses. For instance the method <code class="mthd">getInstance()</code> of the class <code class="abtc">java.util.Calendar</code> is an example of a factory method pattern.</td></tr>

<tr><td>Abstract Factory</td><td>The abstract factory pattern defines an interface to create families of related or dependent objects without specifying their concrete classes. The abstract factory is particularly useful for frameworks and toolkits that work on different operating systems. For instance, if your library provides fancy widgets for the UI, then you may need a family of products that work on MacOS and a similar family of products that work on Windows.</td></tr>

<tr><td>Adapter Pattern</td><td>The Adapter pattern allows two incompatible classes to interoperate that otherwise can't work with eachother. Consider the method <code class="mthd">asList()</code> offered by <code class="abtc">java.util.Arrays</code> as an exampe of the adapter pattern. It takes an array and returns a list.</td></tr>

<tr><td>Bridge Pattern</td><td>The bridge pattern describes how to pull apart two software layers fused together in a single class hierarchy and change them into parallel class hierarchies connected by a bridge</td></tr>

<tr><td>Composite Pattern</td><td>The pattern allows you to treat the whole and the individual parts as one. The closest analogy you can imagine is a tree. The tree is a recursive data-structure where each part itself is a sub-tree except for the leaf nodes.</td></tr>

<tr><td>Decorator Pattern</td><td>The decorator pattern can be thought of as a wrapper or more formally a way to enhance or extend the behavior of an object dynamically. The pattern provides an alternative to subclassing when new functionality is desired. A prominent example of this pattern is the <code class="abtc">java.io</code> package, which includes several decorators. For example the <code class="clazz">BufferedInputStream</code> wraps the <code class="clazz">FileInputStream</code> to provide buffering capabilities.</td></tr>

<tr><td>Facade Pattern</td><td>The facade pattern is defined as a single uber interface to one or more subsystems or interfaces intending to make use of the subsystems easier</td></tr>

<tr><td>Flyweight Pattern</td><td>The pattern advocates reusing state among a large number of fine grained objects. Methods <code class="mthd">java.lang.Boolean.valueOf()</code> and <code class="mthd">java.lang.Integer.valueOf()</code> both return flyweight objects.</td></tr>

<tr><td>Proxy Pattern</td><td>In a proxy pattern setup, a proxy is responsible for representing another object called the subject in front of clients. The real subject is shielded from interacting directly with the clients. The <code class="abtc">java.rmi.*</code> package contains classes for creating proxies. RMI is Remote Method Invocation. It is a mechanism that enables an object on one Java virtual machine to invoke methods on an object in another Java virtual machine.</td></tr>

<tr><td>Chain of Responsibility Pattern</td><td>In a chain of responsibility pattern implementation, the sender's request is passed down a series of handler objects till one of those objects, handles the request or it remains unhandled and falls off the chain. Multiple objects are given a chance to handle the request. This allows us to decouple the sender and the receiver of a request. The <code class="mthd">log()</code> method of the <code class="abtc">java.util.logging.Logger</code> class is an example of this pattern.</td></tr>

<tr><td>Observer Pattern (Publisher/Subscriber)</td><td>The pattern is formally defined as a one to many dependency between objects so that when one object changes state all the dependents are notified. All types implementing the interface <code class="abtc">java.util.EventListener</code> are examples of this pattern.</td></tr>

<tr><td>Interpreter Pattern</td><td>The interpreter pattern converts a language's sentences into its grammar and interprets them.</td></tr>

<tr><td>Command Pattern</td><td>The pattern is defined as representing an action or a request as an object that can then be passed to other objects as parameters, allowing parameterization of clients with requests or actions. Requests can be queued for later execution or logged. Logging requests enables undo operations. Types implementing the interface <code class="abtc">java.lang.Runnable</code> are examples of this pattern.</td></tr>

<tr><td>Iterator Pattern</td><td>An iterator is formally defined as a pattern that allows traversing the elements of an aggregate or a collection sequentially without exposing the underlying implementation. All types implementing the <code class="abtc">java.util.Iterator</code> interface are examples of this pattern.</td></tr>

<tr><td>Mediator Pattern</td><td>The pattern is applied to encapsulate or centralize the interactions amongst a number of objects. Object orientated design may result in behavior being distributed among several classes and lead to too many connections among objects. The encapsulation keeps objects from referring to each other directly andobjects don't hold references to each other anymore. The <code class="abtc">java.util.Timer</code> class represents this pattern where tasks may be scheduled for one-time execution, or for repeated execution at regular intervals in a background thread.</td></tr>

<tr><td>Memento Pattern</td><td>The memento pattern let's us capture the internal state of an object without exposing its internal structure so that the object can be restored to this state later. Classes implementing <code class="abtc">java.io.Serializable</code> interface are examples of the memento pattern.</td></tr>

<tr><td>State Pattern</td><td>The state pattern encapsulates the various states a machine can be in. The machine or the context, as it is called in pattern-speak, can have actions taken on it that propel it into different states. Without the use of the pattern, the code becomes inflexible and littered with if-else conditionals.</td></tr>

<tr><td>Template Method</td><td>The template method pattern defines the skeleton or steps of an algorithm but leaves opportunities for subclasses to override some of the steps with their own implementations. Non-abstract methods of <code class="abtc">java.util.AbstractList</code>, <code class="abtc">java.util.AbstractSet</code> and <code class="abtc">java.util.AbstractMap</code> are examples of this pattern.</td></tr>

<tr><td>Strategy Pattern</td><td>The pattern allows grouping related algorithms under an abstraction, which the client codes against. The abstraction allows switching out one algorithm or policy for another without modifying the client. <code class="abtc">java.util.Comparator</code> has the method <code class="mthd">compare()</code> which allows the user to define the algorithm or strategy to compare two objects of the same type.</td></tr>

<tr><td>Visitor Pattern</td><td>The visitor pattern allows us to define an operation for a class or a class hierarchy without changing the classes of the elements on which the operation is performed. The pattern is suitable in scenarios, where the object structure class or the classes that make up its elements don't change often but new operations over the object structure are desired. <code class="abtc">java.nio.file.FileVisitor</code> interface has an implementation class of <code class="clazz">SimpleFileVisitor</code> which is an example of a visitor. The interface is defined as a visitor of files. An implementation of this interface is provided to the <code class="mthd">Files.walkFileTree()</code> methods to visit each file in a file tree.</td></tr>
 

</table>







</div>
</div>

<div>
 # Notes
 <div>

<table>
<tr><th>Pattern</th><th>Purpose</th></tr>
<tr><td>Prototype Pattern</td><td>Prototype pattern involves creating new objects by copying existing objects. The object whose copies are made is called the prototype. In Java the <code>clone()</code> method of <code>java.lang.Object</code> is an example of this pattern.



</td>
</tr>

<tr><td>Factory Method Pattern</td><td>The factory method is defined as providing an interface for object creation but delegating the actual instantiation of objects to subclasses. For instance the method <code>getInstance()</code> of the class <code>java.util.Calendar</code> is an example of a factory method pattern.</td></tr>

<tr><td>Abstract Factory</td><td>The abstract factory pattern defines an interface to create families of related or dependent objects without specifying their concrete classes. The abstract factory is particularly useful for frameworks and toolkits that work on different operating systems. For instance, if your library provides fancy widgets for the UI, then you may need a family of products that work on MacOS and a similar family of products that work on Windows.</td></tr>

<tr><td>Adapter Pattern</td><td>The Adapter pattern allows two incompatible classes to interoperate that otherwise can't work with eachother. Consider the method <code>asList()</code> offered by <code>java.util.Arrays</code> as an exampe of the adapter pattern. It takes an array and returns a list.</td></tr>

<tr><td>Bridge Pattern</td><td>The bridge pattern describes how to pull apart two software layers fused together in a single class hierarchy and change them into parallel class hierarchies connected by a bridge</td></tr>

<tr><td>Composite Pattern</td><td>The pattern allows you to treat the whole and the individual parts as one. The closest analogy you can imagine is a tree. The tree is a recursive data-structure where each part itself is a sub-tree except for the leaf nodes.</td></tr>

<tr><td>Decorator Pattern</td><td>The decorator pattern can be thought of as a wrapper or more formally a way to enhance or extend the behavior of an object dynamically. The pattern provides an alternative to subclassing when new functionality is desired. A prominent example of this pattern is the <code>java.io</code> package, which includes several decorators. For example the <code>BufferedInputStream</code> wraps the <code>FileInputStream</code> to provide buffering capabilities.</td></tr>

<tr><td>Facade Pattern</td><td>The facade pattern is defined as a single uber interface to one or more subsystems or interfaces intending to make use of the subsystems easier</td></tr>

<tr><td>Flyweight Pattern</td><td>The pattern advocates reusing state among a large number of fine grained objects. Methods <code>java.lang.Boolean.valueOf()</code> and <code>java.lang.Integer.valueOf()</code> both return flyweight objects.</td></tr>

<tr><td>Proxy Pattern</td><td>In a proxy pattern setup, a proxy is responsible for representing another object called the subject in front of clients. The real subject is shielded from interacting directly with the clients. The <code>java.rmi.*</code> package contains classes for creating proxies. RMI is Remote Method Invocation. It is a mechanism that enables an object on one Java virtual machine to invoke methods on an object in another Java virtual machine.</td></tr>

<tr><td>Chain of Responsibility Pattern</td><td>In a chain of responsibility pattern implementation, the sender's request is passed down a series of handler objects till one of those objects, handles the request or it remains unhandled and falls off the chain. Multiple objects are given a chance to handle the request. This allows us to decouple the sender and the receiver of a request. The <code>log()</code> method of the <code>java.util.logging.Logger</code> class is an example of this pattern.</td></tr>

<tr><td>Observer Pattern (Publisher/Subscriber)</td><td>The pattern is formally defined as a one to many dependency between objects so that when one object changes state all the dependents are notified. All types implementing the interface <code>java.util.EventListener</code> are examples of this pattern.</td></tr>

<tr><td>Interpreter Pattern</td><td>The interpreter pattern converts a language's sentences into its grammar and interprets them.</td></tr>

<tr><td>Command Pattern</td><td>The pattern is defined as representing an action or a request as an object that can then be passed to other objects as parameters, allowing parameterization of clients with requests or actions. Requests can be queued for later execution or logged. Logging requests enables undo operations. Types implementing the interface <code>java.lang.Runnable</code> are examples of this pattern.</td></tr>

<tr><td>Iterator Pattern</td><td>An iterator is formally defined as a pattern that allows traversing the elements of an aggregate or a collection sequentially without exposing the underlying implementation. All types implementing the <code>java.util.Iterator</code> interface are examples of this pattern.</td></tr>

<tr><td>Mediator Pattern</td><td>The pattern is applied to encapsulate or centralize the interactions amongst a number of objects. Object orientated design may result in behavior being distributed among several classes and lead to too many connections among objects. The encapsulation keeps objects from referring to each other directly andobjects don't hold references to each other anymore. The <code>java.util.Timer</code> class represents this pattern where tasks may be scheduled for one-time execution, or for repeated execution at regular intervals in a background thread.</td></tr>

<tr><td>Memento Pattern</td><td>The memento pattern let's us capture the internal state of an object without exposing its internal structure so that the object can be restored to this state later. Classes implementing <code>java.io.Serializable</code> interface are examples of the memento pattern.</td></tr>

<tr><td>State Pattern</td><td>The state pattern encapsulates the various states a machine can be in. The machine or the context, as it is called in pattern-speak, can have actions taken on it that propel it into different states. Without the use of the pattern, the code becomes inflexible and littered with if-else conditionals.</td></tr>

<tr><td>Template Method</td><td>The template method pattern defines the skeleton or steps of an algorithm but leaves opportunities for subclasses to override some of the steps with their own implementations. Non-abstract methods of <code>java.util.AbstractList</code>, <code>java.util.AbstractSet</code> and <code>java.util.AbstractMap</code> are examples of this pattern.</td></tr>

<tr><td>Strategy Pattern</td><td>The pattern allows grouping related algorithms under an abstraction, which the client codes against. The abstraction allows switching out one algorithm or policy for another without modifying the client. <code>java.util.Comparator</code> has the method <code>compare()</code> which allows the user to define the algorithm or strategy to compare two objects of the same type.</td></tr>

<tr><td>Visitor Pattern</td><td>The visitor pattern allows us to define an operation for a class or a class hierarchy without changing the classes of the elements on which the operation is performed. The pattern is suitable in scenarios, where the object structure class or the classes that make up its elements don't change often but new operations over the object structure are desired. <code>java.nio.file.FileVisitor</code> interface has an implementation class of <code>SimpleFileVisitor</code> which is an example of a visitor. The interface is defined as a visitor of files. An implementation of this interface is provided to the <code>Files.walkFileTree()</code> methods to visit each file in a file tree.</td></tr>
 

</table>







</div>
</div>

This summarizes the different patterns and their uses. It also includes the example usages of the patterns in the Java API.

Pattern	Purpose
Prototype Pattern	Prototype pattern involves creating new objects by copying existing objects. The object whose copies are made is called the prototype. In Java the `clone()` method of `java.lang.Object` is an example of this pattern.
Factory Method Pattern	The factory method is defined as providing an interface for object creation but delegating the actual instantiation of objects to subclasses. For instance the method `getInstance()` of the class `java.util.Calendar` is an example of a factory method pattern.
Abstract Factory	The abstract factory pattern defines an interface to create families of related or dependent objects without specifying their concrete classes. The abstract factory is particularly useful for frameworks and toolkits that work on different operating systems. For instance, if your library provides fancy widgets for the UI, then you may need a family of products that work on MacOS and a similar family of products that work on Windows.
Adapter Pattern	The Adapter pattern allows two incompatible classes to interoperate that otherwise can't work with eachother. Consider the method `asList()` offered by `java.util.Arrays` as an exampe of the adapter pattern. It takes an array and returns a list. ...

Java Ecosystem

Methods

Classes

Interfaces

Inheritance

Lambda Expressions

Generics

Multi-Threading

Memory Management

Collections

Exceptions

Reflection

Serialization

Miscellaneous Topics

Java in Practice

Patterns

The End

Cheat Sheet

Notes