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 bounded type parameters?</p>
    </div>
    <div class="ans">
        <p>When you want to restrict the types that can be used as type arguments in a parameterized type, you can do so by bounding the type parameter. For instance, say you are designing a specialized collection class that should only contain numbers. The type parameter can be bounded by the <code class="clazz">Number</code> class to ensure that consumers of your specialized collection can never add items which aren't of type <code class="clazz">Number</code> or one of its subclass. Let's see how you'll do it without specifying a bound first:</p>
<b>

```java
 class NumberCollection<T> {

    List<T> list = new ArrayList<>();

    // Method compares integer portions of each
    // value stored in the list and prints those
    // that are greater than the method argument
    public void printGreater(T other) {
        for (T item : list) {
            // crude way to get integer portions
            int val1 = Double.valueOf(item.toString()).intValue();
            int val2 = Double.valueOf(other.toString()).intValue();
            if (val1 > val2)
                System.out.println(item);
        }
    }

    public void add(T item) {
        list.add(item);
    }
}
```
</b>
<p>Note that for the code above, <span class="hi-yl">the <i><b>type parameter</b></i> is <code class="clazz">T</code>.</span> We can instantiate the specialized class as follows:</p>
<b>

```java
    NumberCollection<Integer> myIntegerList = new NumberCollection<>();
    myIntegerList.add(5);
    myIntegerList.add(4);
    myIntegerList.printGreater(4);
```
</b>
<p><span class="hi-yl">Note that the <code class="clazz">Integer</code> we specify in the statement <code class="mthd">NumberCollection&lt;Integer&gt; myIntegerList = new NumberCollection<>();</code> is the <b><i>type argument</i></b>.</span></p>
<p>There are two problems with the approach above:</p>
<ul>
<li><p>A consumer of the class can instantiate an instance with a type argument that is not of type <code class="clazz">Number</code> resulting in a runtime exception. For instance, an unsuspecting consumer can create a list parametrized on type argument <code class="clazz">String</code> and run into a runtime exception. Below snippet will compile and throw a runtime exception.</p>
<b>

```java
    NumberCollection<String> myStringList = new NumberCollection<>();
    myStringList.add("hello");
    myStringList.printGreater("world");
```
</b>

</li>
<li><p>The type <code class="clazz">T</code> is unbounded and only methods of the <code class="clazz">Object</code> class can be invoked on variables of type <code class="clazz">T</code> declared in the class <code class="clazz">NumberCollection</code> unless we use casting.</p></li>
</ul>
</div>
</div>


<div>
   # Question # 1
    <div>
        <p>What are bounded type parameters?</p>
    </div>
    <div>
        <p>When you want to restrict the types that can be used as type arguments in a parameterized type, you can do so by bounding the type parameter. For instance, say you are designing a specialized collection class that should only contain numbers. The type parameter can be bounded by the <code>Number</code> class to ensure that consumers of your specialized collection can never add items which aren't of type <code>Number</code> or one of its subclass. Let's see how you'll do it without specifying a bound first:</p>
<b>

```java
 class NumberCollection<T> {

    List<T> list = new ArrayList<>();

    // Method compares integer portions of each
    // value stored in the list and prints those
    // that are greater than the method argument
    public void printGreater(T other) {
        for (T item : list) {
            // crude way to get integer portions
            int val1 = Double.valueOf(item.toString()).intValue();
            int val2 = Double.valueOf(other.toString()).intValue();
            if (val1 > val2)
                System.out.println(item);
        }
    }

    public void add(T item) {
        list.add(item);
    }
}
```
</b>
<p>Note that for the code above, <span>the <i><b>type parameter</b></i> is <code>T</code>.</span> We can instantiate the specialized class as follows:</p>
<b>

```java
    NumberCollection<Integer> myIntegerList = new NumberCollection<>();
    myIntegerList.add(5);
    myIntegerList.add(4);
    myIntegerList.printGreater(4);
```
</b>
<p><span>Note that the <code>Integer</code> we specify in the statement <code>NumberCollection&lt;Integer&gt; myIntegerList = new NumberCollection<>();</code> is the <b><i>type argument</i></b>.</span></p>
<p>There are two problems with the approach above:</p>
<ul>
<li><p>A consumer of the class can instantiate an instance with a type argument that is not of type <code>Number</code> resulting in a runtime exception. For instance, an unsuspecting consumer can create a list parametrized on type argument <code>String</code> and run into a runtime exception. Below snippet will compile and throw a runtime exception.</p>
<b>

```java
    NumberCollection<String> myStringList = new NumberCollection<>();
    myStringList.add("hello");
    myStringList.printGreater("world");
```
</b>

</li>
<li><p>The type <code>T</code> is unbounded and only methods of the <code>Object</code> class can be invoked on variables of type <code>T</code> declared in the class <code>NumberCollection</code> unless we use casting.</p></li>
</ul>
</div>
</div>


This lesson discusses bounded types in Java's 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

Bounded Types

Question # 1