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 is the Builder pattern?</p>
    </div>
    <div class="ans">
        <p>Builder is one of the most common creational patterns out there. Usually, when a class evolves it adds parameters to its existing constructors and creates a whole slew of new constructors. Eventually, a class will end up with a number of very similar constructors that differ in the number of their parameters.</p>
<b>

```java
class SomeClass {

    // telescoping constructors

    SomeClass() { }

    SomeClass(param1) { }

    SomeClass(param1, param2) { }

    SomeClass(param1, param2, param3) { }

    SomeClass(param1, param2, param3, param4) { }

}
```
</b>
<p>The list of constructors starts to resemble a telescope and the pattern is called <b>telescoping constructors</b>. The pattern reduces readability and increases the chance of error by the consumers of the class.</p>

<p>The builder pattern's idea is instead of making the desired object directly, the client calls a constructor (or static factory) with all of the required parameters and gets a builder object. Then the client calls setter-like methods on the builder object to set each optional parameter of interest. Finally, the client calls a parameterless build method to generate the object. Let's see an example to better understand the concept.</p>
<p>Imagine we have a class <code class="clazz">Burger</code> that represents a burger a customer orders. The <code class="clazz">Burger</code> class instantiation requires at a minimum of a bun and a patty object. Thereafter the burger can have other optional parameters that may or may not be provided at instantiation time. Let's see how the class looks before applying the builder pattern.</p>
## Before applying builder pattern
<b>

```java
    class Burger {

        private final Bun bun;
        private final Patty patty;

        private Collection<Veggies> veggies;
        private Dressing dressing;
        private boolean isSpicy;
        private boolean wellDone;

        // Constructs the simplest burger
        public Burger(Bun bun, Patty patty) {

        }

        // Constructs a burger with dressing
        public Burger(Bun bun, Patty patty, Dressing dressing) {

        }

        // Constructs a burger with dressing
        public Burger(Bun bun, Patty patty, Dressing dressing, List<Veggies> veggies) {

        }

        // Constructs a spicy burger with dressing and veggies
        public Burger(Bun bun, Patty patty, Dressing dressing, List<Veggies> veggies, 
                            boolean isSpicy) {
        }

        // Constructs a welldone, spicy burger with dressing and veggies
        public Burger(Bun bun, Patty patty, Dressing dressing, List<Veggies> veggies,
                            boolean isSpicy, boolean wellDone) { 
        }
    }
```
</b>

<p>As you can see the class has several constructors which are all similar and differ by just one parameter. If your restaurant becomes popular you are likely to introduce more varied burgers for customers which would mean additional constructors. The way out of this mess is to use the builder pattern.</p>
## After applying builder pattern
<b>

```java
class Burger {

    private final Bun bun;
    private final Patty patty;

    private Collection<Veggies> veggies;
    private Dressing dressing;
    private boolean isSpicy;
    private boolean wellDone;

    static class Builder {
        private final Bun bun;
        private final Patty patty;

        private Collection<Veggies> veggies;
        private Dressing dressing;
        private boolean isSpicy;
        private boolean wellDone;

        // Builder constructor takes in the mandatory
        // fields
        public Builder(Bun bun, Patty patty) {
            this.bun = bun;
            this.patty = patty;
        }

        public Builder setVeggies(List<Veggies> veggies) {
            this.veggies = Collections.unmodifiableCollection(veggies);
            return this;
        }

        public Builder setDressing(Dressing dressing) {
            this.dressing = dressing;
            return this;
        }

        public Builder setSpicy(boolean spicy) {
            this.isSpicy = spicy;
            return this;
        }

        public Builder setWelldone(boolean wellDone) {
            this.wellDone = wellDone;
            return this;
        }

        public Burger build() {
            return new Burger(this);
        }
    }

    private Burger(Builder builder) {
        this.bun = builder.bun;
        this.patty = builder.patty;
        this.dressing = builder.dressing;
        this.veggies = builder.veggies;
        this.isSpicy = builder.isSpicy;
        this.wellDone = builder.wellDone;
    }
}
```
</b>

<p>The trick to the builder pattern is to create a static nested class called <code class="clazz">Builder</code> which becomes responsible for creating <code class="clazz">Burger</code> objects. The sole constructor for the <code class="clazz">Burger</code> class is marked private and takes in a single element of type <code class="clazz">Builder</code>. This forces the external consumers to use the <code class="clazz">Builder</code> class to create <code class="clazz">Burger</code> objects. The resulting code is much more readable, pleasant and has minimal chance of introducing developer error. The usage is shown below:</p>
## Builder pattern usage
<b>

```java
        Burger.Builder builder = new Burger.Builder(new Bun(), new Patty());
        
        // A fully loaded burger
        Burger burger = builder.setDressing(Dressing.Mayonnaise)
                .setWelldone(true)
                .setSpicy(true)
                .setVeggies(Arrays.asList(Veggies.Avocado, Veggies.Onion))
                .build();
```
</b>
</div>
</div>


<div>
   # Question # 1
    <div>
        <p>What is the Builder pattern?</p>
    </div>
    <div>
        <p>Builder is one of the most common creational patterns out there. Usually, when a class evolves it adds parameters to its existing constructors and creates a whole slew of new constructors. Eventually, a class will end up with a number of very similar constructors that differ in the number of their parameters.</p>
<b>

```java
class SomeClass {

    // telescoping constructors

    SomeClass() { }

    SomeClass(param1) { }

    SomeClass(param1, param2) { }

    SomeClass(param1, param2, param3) { }

    SomeClass(param1, param2, param3, param4) { }

}
```
</b>
<p>The list of constructors starts to resemble a telescope and the pattern is called <b>telescoping constructors</b>. The pattern reduces readability and increases the chance of error by the consumers of the class.</p>

<p>The builder pattern's idea is instead of making the desired object directly, the client calls a constructor (or static factory) with all of the required parameters and gets a builder object. Then the client calls setter-like methods on the builder object to set each optional parameter of interest. Finally, the client calls a parameterless build method to generate the object. Let's see an example to better understand the concept.</p>
<p>Imagine we have a class <code>Burger</code> that represents a burger a customer orders. The <code>Burger</code> class instantiation requires at a minimum of a bun and a patty object. Thereafter the burger can have other optional parameters that may or may not be provided at instantiation time. Let's see how the class looks before applying the builder pattern.</p>
## Before applying builder pattern
<b>

```java
    class Burger {

        private final Bun bun;
        private final Patty patty;

        private Collection<Veggies> veggies;
        private Dressing dressing;
        private boolean isSpicy;
        private boolean wellDone;

        // Constructs the simplest burger
        public Burger(Bun bun, Patty patty) {

        }

        // Constructs a burger with dressing
        public Burger(Bun bun, Patty patty, Dressing dressing) {

        }

        // Constructs a burger with dressing
        public Burger(Bun bun, Patty patty, Dressing dressing, List<Veggies> veggies) {

        }

        // Constructs a spicy burger with dressing and veggies
        public Burger(Bun bun, Patty patty, Dressing dressing, List<Veggies> veggies, 
                            boolean isSpicy) {
        }

        // Constructs a welldone, spicy burger with dressing and veggies
        public Burger(Bun bun, Patty patty, Dressing dressing, List<Veggies> veggies,
                            boolean isSpicy, boolean wellDone) { 
        }
    }
```
</b>

<p>As you can see the class has several constructors which are all similar and differ by just one parameter. If your restaurant becomes popular you are likely to introduce more varied burgers for customers which would mean additional constructors. The way out of this mess is to use the builder pattern.</p>
## After applying builder pattern
<b>

```java
class Burger {

    private final Bun bun;
    private final Patty patty;

    private Collection<Veggies> veggies;
    private Dressing dressing;
    private boolean isSpicy;
    private boolean wellDone;

    static class Builder {
        private final Bun bun;
        private final Patty patty;

        private Collection<Veggies> veggies;
        private Dressing dressing;
        private boolean isSpicy;
        private boolean wellDone;

        // Builder constructor takes in the mandatory
        // fields
        public Builder(Bun bun, Patty patty) {
            this.bun = bun;
            this.patty = patty;
        }

        public Builder setVeggies(List<Veggies> veggies) {
            this.veggies = Collections.unmodifiableCollection(veggies);
            return this;
        }

        public Builder setDressing(Dressing dressing) {
            this.dressing = dressing;
            return this;
        }

        public Builder setSpicy(boolean spicy) {
            this.isSpicy = spicy;
            return this;
        }

        public Builder setWelldone(boolean wellDone) {
            this.wellDone = wellDone;
            return this;
        }

        public Burger build() {
            return new Burger(this);
        }
    }

    private Burger(Builder builder) {
        this.bun = builder.bun;
        this.patty = builder.patty;
        this.dressing = builder.dressing;
        this.veggies = builder.veggies;
        this.isSpicy = builder.isSpicy;
        this.wellDone = builder.wellDone;
    }
}
```
</b>

<p>The trick to the builder pattern is to create a static nested class called <code>Builder</code> which becomes responsible for creating <code>Burger</code> objects. The sole constructor for the <code>Burger</code> class is marked private and takes in a single element of type <code>Builder</code>. This forces the external consumers to use the <code>Builder</code> class to create <code>Burger</code> objects. The resulting code is much more readable, pleasant and has minimal chance of introducing developer error. The usage is shown below:</p>
## Builder pattern usage
<b>

```java
        Burger.Builder builder = new Burger.Builder(new Bun(), new Patty());
        
        // A fully loaded burger
        Burger burger = builder.setDressing(Dressing.Mayonnaise)
                .setWelldone(true)
                .setSpicy(true)
                .setVeggies(Arrays.asList(Veggies.Avocado, Veggies.Onion))
                .build();
```
</b>
</div>
</div>


This lesson discusses the Builder pattern which is extensively used 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

Builder

Question # 1