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 on using Generics
<div class="ans">
<ol>
<li>Don't use raw types as they can cause code to fail at runtime with casting exceptions. Using raw types loses type safety and expressiveness advantages of generics. You can put any element
into a collection with a raw type, easily corrupting the collection’s type invariant.</li>
<li>Eliminate checked warnings. If you eliminate all warnings, you are assured that your code is typesafe, which is a very good thing. It means that you won’t get a <code class="clazz">ClassCastException</code> at runtime, and it increases your confidence that your program is behaving as you intended.</li>

<li>Always use the <code class="anno">SuppressWarnings</code> annotation on the smallest scope possible.</li>

<li>Use Lists instead of arrays because Lists provide greater type safety.

<ul>
<li>Consider the following snippet, which compiles fine but fails at runtime.


```java
class Person {} // a dummy class

// The following snippet compiles but fails at runtime
Object[] personArray = new Person[10];
personArray[0] = new Integer(0); // throws ArrayStoreException at runtime
```

On the contrary, the same code written using lists would fail at compile time. It is always preferred to catch errors at compile time than runtime.


```java
// Fails at compile time
List<Person> list = new LinkedList<>();
list.add(new Integer(5));
```


</li>
<li>Arrays are covariant which means an array of type <code class="clazz">Person</code> is a subtype of an array of its super class <code class="clazz">Object</code> whereas this isn't true for generics. <code class="clazz">List&lt;Person&gt;</code> isn't a subtype of <code class="clazz">List&lt;Object&gt;</code>. </li>
<li>Arrays know and enforce their types at runtime whereas generics enforce their type constraints only at compile time (erasure).</li>

</ul>
</li>

<li>Generic arrays are illegal in Java. It is illegal to create an array of a generic type, a parameterized type, or a type parameter because they aren't typesafe.</li>

<li>Arrays are covariant and reified; generics are invariant and erased. Consequently, arrays provide runtime type safety but not compile-time type safety and vice versa for generics. Generally speaking, arrays and generics don’t mix well.</li>

<li>Use casting or object arrays when working with generic arrays. As explained we can't do something like <code class="mthd">T[] myGenericArray = new T[10];</code> however there are times where want to use a generic array e.g. the following class:


```java
public class Store<T> {

 T[] items;
}
```

There are two options to deal with generic arrays: 

<ul>
<li>Initialize an <code class="clazz">Object</code> array and cast it to the generic type.


```java
 // casting object array to generic type
 items = (T[]) new Object[size];
```

</li>
<li>Instead of declaring an <code class="mthd">T[]</code> array, declare an <code class="mthd">Object[]</code> array and cast to generic type when retrieving objects from the array.


```java
 Object[] items = new Object[10];
 T i = (T) items[0];
```

</li>
</ul>
</li>

<li>Use generic methods instead of non-generic method that require clients to cast arguments or return types.</li>

<li>Use bounded wildcards to make APIs more flexible.</li>

<li>Use producer-extends and consumer-super paradigm when declaring input parameters.</li>

<li>Don't use wildcards as return types from methods.
## Bad Practice



```java
 Set<? extends Number> someMethod() {
 // ... method body
 }
```


</li>

<li>Adding bounded or unbounded wildcards as parameters can increase API flexibility.</li>

</ol>
</div>

<div>
 # Notes on using Generics
<div>
<ol>
<li>Don't use raw types as they can cause code to fail at runtime with casting exceptions. Using raw types loses type safety and expressiveness advantages of generics. You can put any element
into a collection with a raw type, easily corrupting the collection’s type invariant.</li>
<li>Eliminate checked warnings. If you eliminate all warnings, you are assured that your code is typesafe, which is a very good thing. It means that you won’t get a <code>ClassCastException</code> at runtime, and it increases your confidence that your program is behaving as you intended.</li>

<li>Always use the <code>SuppressWarnings</code> annotation on the smallest scope possible.</li>

<li>Use Lists instead of arrays because Lists provide greater type safety.

<ul>
<li>Consider the following snippet, which compiles fine but fails at runtime.


```java
class Person {} // a dummy class

// The following snippet compiles but fails at runtime
Object[] personArray = new Person[10];
personArray[0] = new Integer(0); // throws ArrayStoreException at runtime
```

On the contrary, the same code written using lists would fail at compile time. It is always preferred to catch errors at compile time than runtime.


```java
// Fails at compile time
List<Person> list = new LinkedList<>();
list.add(new Integer(5));
```


</li>
<li>Arrays are covariant which means an array of type <code>Person</code> is a subtype of an array of its super class <code>Object</code> whereas this isn't true for generics. <code>List&lt;Person&gt;</code> isn't a subtype of <code>List&lt;Object&gt;</code>. </li>
<li>Arrays know and enforce their types at runtime whereas generics enforce their type constraints only at compile time (erasure).</li>

</ul>
</li>

<li>Generic arrays are illegal in Java. It is illegal to create an array of a generic type, a parameterized type, or a type parameter because they aren't typesafe.</li>

<li>Arrays are covariant and reified; generics are invariant and erased. Consequently, arrays provide runtime type safety but not compile-time type safety and vice versa for generics. Generally speaking, arrays and generics don’t mix well.</li>

<li>Use casting or object arrays when working with generic arrays. As explained we can't do something like <code>T[] myGenericArray = new T[10];</code> however there are times where want to use a generic array e.g. the following class:


```java
public class Store<T> {

 T[] items;
}
```

There are two options to deal with generic arrays: 

<ul>
<li>Initialize an <code>Object</code> array and cast it to the generic type.


```java
 // casting object array to generic type
 items = (T[]) new Object[size];
```

</li>
<li>Instead of declaring an <code>T[]</code> array, declare an <code>Object[]</code> array and cast to generic type when retrieving objects from the array.


```java
 Object[] items = new Object[10];
 T i = (T) items[0];
```

</li>
</ul>
</li>

<li>Use generic methods instead of non-generic method that require clients to cast arguments or return types.</li>

<li>Use bounded wildcards to make APIs more flexible.</li>

<li>Use producer-extends and consumer-super paradigm when declaring input parameters.</li>

<li>Don't use wildcards as return types from methods.
## Bad Practice



```java
 Set<? extends Number> someMethod() {
 // ... method body
 }
```


</li>

<li>Adding bounded or unbounded wildcards as parameters can increase API flexibility.</li>

</ol>
</div>

This lesson lists caveats one should be aware of when working with generics in Java.  

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

Using Generics

Notes on using Generics