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">
   <h4>Question # 1</h4>
    <div class="qtn">
        <p>When were generics introduced in the Java language?</p>
    </div>
    <div class="ans">
        <p>Generics in Java were released with <b>J2SE 1.5</b> in 2004. Later on, <b>J2SE 1.5</b> was renamed to Java <b>SE 5.0</b>.</p>
</div>
</div>

<div class="card">
   <h4>Question # 2</h4>
    <div class="qtn">
        <p>Why should we use generics in Java?</p>
    </div>
    <div class="ans">
        <p>Generics help with the following use-cases</p>

<ul>
<li><p>Enforcing stronger type checking at compile time for greater <i>type-safety</i></p></li>
<li><p>Elimination of casts</p></li>
<li><p>Implementation of generic algorithms</p></li>
</ul>
</div>
</div>

<div class="card">
   <h4>Question # 3</h4>
    <div class="qtn">
        <p>What is type safety?</p>
    </div>
    <div class="ans">
        <p><span class="hi-yl-b">Type safety is the extent to which a programming language discourages or prevents type errors.</span> An example would be treating an <code class="clazz">int</code> like a <code class="clazz">float</code>. Observe the <code class="mthd">sum()</code> method below:</p>
<b>

```java
    int sum(ArrayList list) {

        int sum = 0;
        for (int i = 0; i < list.size(); i++)
            sum += (int) list.get(i);

        return sum;
    }
```
</b>
<p>If the above method is invoked as follows, it'll result in a cast exception at runtime since we are trying to treat a string as an integer. <span class="hi-yl">Note that the code snippets would compile without errors but fail at runtime.</span></p>
<b>

```java
        ArrayList myList = new ArrayList();

        myList.add("Hello");
        myList.add(2);

        sum(myList);
```
</b>
<p>Generics allow us to catch such type errors at compile time and also rid us of the need to cast objects into our intended data-type. The above code can be fixed like so:</p>
<b>

```java
    int sum(List<Integer> list) {

        int sum = 0;
        for (int i = 0; i < list.size(); i++)
            sum += list.get(i);

        return sum;
    }
```
</b>
<p>and the code to invoke the <code class="mthd">sum()</code> method can be rewritten as:</p>
<b>

```java
        List<Integer> myList = new ArrayList();

        // This will get caught at compile time
        myList.add("Hello");
        myList.add(2);

        sum(myList);
```
</b>
</div>
</div>

<div class="card">
   # Question # 1
    <div class="qtn">
        <p>When were generics introduced in the Java language?</p>
    </div>
    <div class="ans">
        <p>Generics in Java were released with <b>J2SE 1.5</b> in 2004. Later on, <b>J2SE 1.5</b> was renamed to Java <b>SE 5.0</b>.</p>
</div>
</div>

<div class="card">
   # Question # 2
    <div class="qtn">
        <p>Why should we use generics in Java?</p>
    </div>
    <div class="ans">
        <p>Generics help with the following use-cases</p>

<ul>
<li><p>Enforcing stronger type checking at compile time for greater <i>type-safety</i></p></li>
<li><p>Elimination of casts</p></li>
<li><p>Implementation of generic algorithms</p></li>
</ul>
</div>
</div>

<div class="card">
   # Question # 3
    <div class="qtn">
        <p>What is type safety?</p>
    </div>
    <div class="ans">
        <p><span class="hi-yl-b">Type safety is the extent to which a programming language discourages or prevents type errors.</span> An example would be treating an <code class="clazz">int</code> like a <code class="clazz">float</code>. Observe the <code class="mthd">sum()</code> method below:</p>
<b>

```java
    int sum(ArrayList list) {

        int sum = 0;
        for (int i = 0; i < list.size(); i++)
            sum += (int) list.get(i);

        return sum;
    }
```
</b>
<p>If the above method is invoked as follows, it'll result in a cast exception at runtime since we are trying to treat a string as an integer. <span class="hi-yl">Note that the code snippets would compile without errors but fail at runtime.</span></p>
<b>

```java
        ArrayList myList = new ArrayList();

        myList.add("Hello");
        myList.add(2);

        sum(myList);
```
</b>
<p>Generics allow us to catch such type errors at compile time and also rid us of the need to cast objects into our intended data-type. The above code can be fixed like so:</p>
<b>

```java
    int sum(List<Integer> list) {

        int sum = 0;
        for (int i = 0; i < list.size(); i++)
            sum += list.get(i);

        return sum;
    }
```
</b>
<p>and the code to invoke the <code class="mthd">sum()</code> method can be rewritten as:</p>
<b>

```java
        List<Integer> myList = new ArrayList();

        // This will get caught at compile time
        myList.add("Hello");
        myList.add(2);

        sum(myList);
```
</b>
</div>
</div>

<div>
   # Question # 1
    <div>
        <p>When were generics introduced in the Java language?</p>
    </div>
    <div>
        <p>Generics in Java were released with <b>J2SE 1.5</b> in 2004. Later on, <b>J2SE 1.5</b> was renamed to Java <b>SE 5.0</b>.</p>
</div>
</div>

<div>
   # Question # 2
    <div>
        <p>Why should we use generics in Java?</p>
    </div>
    <div>
        <p>Generics help with the following use-cases</p>

<ul>
<li><p>Enforcing stronger type checking at compile time for greater <i>type-safety</i></p></li>
<li><p>Elimination of casts</p></li>
<li><p>Implementation of generic algorithms</p></li>
</ul>
</div>
</div>

<div>
   # Question # 3
    <div>
        <p>What is type safety?</p>
    </div>
    <div>
        <p><span>Type safety is the extent to which a programming language discourages or prevents type errors.</span> An example would be treating an <code>int</code> like a <code>float</code>. Observe the <code>sum()</code> method below:</p>
<b>

```java
    int sum(ArrayList list) {

        int sum = 0;
        for (int i = 0; i < list.size(); i++)
            sum += (int) list.get(i);

        return sum;
    }
```
</b>
<p>If the above method is invoked as follows, it'll result in a cast exception at runtime since we are trying to treat a string as an integer. <span>Note that the code snippets would compile without errors but fail at runtime.</span></p>
<b>

```java
        ArrayList myList = new ArrayList();

        myList.add("Hello");
        myList.add(2);

        sum(myList);
```
</b>
<p>Generics allow us to catch such type errors at compile time and also rid us of the need to cast objects into our intended data-type. The above code can be fixed like so:</p>
<b>

```java
    int sum(List<Integer> list) {

        int sum = 0;
        for (int i = 0; i < list.size(); i++)
            sum += list.get(i);

        return sum;
    }
```
</b>
<p>and the code to invoke the <code>sum()</code> method can be rewritten as:</p>
<b>

```java
        List<Integer> myList = new ArrayList();

        // This will get caught at compile time
        myList.add("Hello");
        myList.add(2);

        sum(myList);
```
</b>
</div>
</div>

This lesson introduces the concept of 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

Why Generics

Question # 1

Question # 2

Question # 3