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">
   # Question # 1
    <div class="qtn">
        <p>What are bridge methods?</p>
    </div>
    <div class="ans">
        <p><span class="hi-yl-b">Bridge methods are synthetic methods created by the compiler as part of the erasure process when compiling a class or interface that extends a parameterized class or implements a parameterized interface.</span> To understand bridge methods, let's try to understand the problem that bridge methods solve. Consider the following setup, where the class <code class="clazz">purposelessClass</code> implements the generic <code class="intf">uselessInterface</code> interface.</p>
## Before type erasure
<b>

```java
interface UselessInterface<T> {

    public void print(T o);
}

class PurposelessClass implements UselessInterface<Integer> {

    @Override
    public void print(Integer t) {

    }
    
}
```
</b>

<p>When type erasure is applied on the interface and the class we'll get the following form:</p>
## After type erasure
<b>

```java
interface UselessInterface {

    public void print(Object o);
}

class PurposelessClass implements UselessInterface<Integer> {

    @Override
    public void print(Integer t) {

    }
    
}
```
</b>

<p>Now the signature of the method <code class="mthd">print</code> in the class and the interface are no more similar. The class's <code class="mthd">print</code> method takes in an integer whereas the interface's <code class="mthd">print</code> method takes in an object. The class is no longer overriding the interface's print method that it implements. The compiler steps in at this moment and to preserve polymorphism inserts a method in the class that acts as a <i>bridge</i> between the two methods so that subtyping correctly works. The class definition would look like:</p>

<b>

```java
interface UselessInterface {

    public void print(Object o);
}

class PurposelessClass implements UselessInterface<Integer> {

    @Override
    public void print(Integer t) {

    }

    // BRIDGE METHOD
    // Synthetic method inserted by compiler 
    public void print(Object t) {
        print((Integer)t); // <--- the method casts the received Object to Integer and calls the intended overridden method. 
    }
    
}
```
</b>

<p>Bridge methods can show up in a stack trace and can also be seen in the list of methods received from reflection. The below snippet reflectively retrieves methods names for the <code class="clazz">PurposelessClass</code> class which lists two methods with the name print and one of them is the synthetic one inserted by the compiler.</p> 

<p></p>
</div>
</div>


<div>
   # Question # 1
    <div>
        <p>What are bridge methods?</p>
    </div>
    <div>
        <p><span>Bridge methods are synthetic methods created by the compiler as part of the erasure process when compiling a class or interface that extends a parameterized class or implements a parameterized interface.</span> To understand bridge methods, let's try to understand the problem that bridge methods solve. Consider the following setup, where the class <code>purposelessClass</code> implements the generic <code>uselessInterface</code> interface.</p>
## Before type erasure
<b>

```java
interface UselessInterface<T> {

    public void print(T o);
}

class PurposelessClass implements UselessInterface<Integer> {

    @Override
    public void print(Integer t) {

    }
    
}
```
</b>

<p>When type erasure is applied on the interface and the class we'll get the following form:</p>
## After type erasure
<b>

```java
interface UselessInterface {

    public void print(Object o);
}

class PurposelessClass implements UselessInterface<Integer> {

    @Override
    public void print(Integer t) {

    }
    
}
```
</b>

<p>Now the signature of the method <code>print</code> in the class and the interface are no more similar. The class's <code>print</code> method takes in an integer whereas the interface's <code>print</code> method takes in an object. The class is no longer overriding the interface's print method that it implements. The compiler steps in at this moment and to preserve polymorphism inserts a method in the class that acts as a <i>bridge</i> between the two methods so that subtyping correctly works. The class definition would look like:</p>

<b>

```java
interface UselessInterface {

    public void print(Object o);
}

class PurposelessClass implements UselessInterface<Integer> {

    @Override
    public void print(Integer t) {

    }

    // BRIDGE METHOD
    // Synthetic method inserted by compiler 
    public void print(Object t) {
        print((Integer)t); // <--- the method casts the received Object to Integer and calls the intended overridden method. 
    }
    
}
```
</b>

<p>Bridge methods can show up in a stack trace and can also be seen in the list of methods received from reflection. The below snippet reflectively retrieves methods names for the <code>PurposelessClass</code> class which lists two methods with the name print and one of them is the synthetic one inserted by the compiler.</p> 

<p></p>
</div>
</div>


This lesson explains bridge methods created by the compiler when working with generics.

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

Bridge Methods

Question # 1