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 Objects

<div class="ans">
<ol>
<li><p><b>Set object references to null</b> in classes that manager their own memory to avoid memory leaks. Consider the class below:</p>
<b>

```java
public class LeakyStack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public LeakyStack() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        return elements[--size];
    }

    private void ensureCapacity() {
        if (elements.length == size)
            elements = Array.copyOf(elements, 2 * size + 1);
    }
}
```
</b>
<p>The <code class="clazz">LeakyStack</code> leaks memory whenever it returns an item in the <code class="mthd">pop()</code> method because the corresponding slot of the <code class="mthd">elements</code>array holds a reference to the returned object till it is overwritten. The fix for the method is shown below:</p> 
<b>

```java
    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        Object object = elements[--size];
        
        return object;
    }
```
</b>
</li>
<li><p><b>WeakHashMap</b> may be a good data structure of choice when designing caches where an entry's lifetime in the cache is dependent on the number of references to the entry rather than other factors.</p></li>

<li><p><b>Register client callbacks as weak references</b> if clients don't explicitly deregister them.</p></li>

</ol>
</div>


<div>
   # Notes on Using Objects

<div>
<ol>
<li><p><b>Set object references to null</b> in classes that manager their own memory to avoid memory leaks. Consider the class below:</p>
<b>

```java
public class LeakyStack {
    private Object[] elements;
    private int size = 0;
    private static final int DEFAULT_INITIAL_CAPACITY = 16;

    public LeakyStack() {
        elements = new Object[DEFAULT_INITIAL_CAPACITY];
    }

    public void push(Object e) {
        ensureCapacity();
        elements[size++] = e;
    }

    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        return elements[--size];
    }

    private void ensureCapacity() {
        if (elements.length == size)
            elements = Array.copyOf(elements, 2 * size + 1);
    }
}
```
</b>
<p>The <code>LeakyStack</code> leaks memory whenever it returns an item in the <code>pop()</code> method because the corresponding slot of the <code>elements</code>array holds a reference to the returned object till it is overwritten. The fix for the method is shown below:</p> 
<b>

```java
    public Object pop() {
        if (size == 0)
            throw new EmptyStackException();
        Object object = elements[--size];
        
        return object;
    }
```
</b>
</li>
<li><p><b>WeakHashMap</b> may be a good data structure of choice when designing caches where an entry's lifetime in the cache is dependent on the number of references to the entry rather than other factors.</p></li>

<li><p><b>Register client callbacks as weak references</b> if clients don't explicitly deregister them.</p></li>

</ol>
</div>


This lesson discusses the caveats of working with Java objects.

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 Objects