skip to content

What does the `new` keyword do in Java when you create an object?

level: juniorimportance: must knowfreq 78%

answer

  1. allocate heap memory
  2. default-init fields then run constructor
  3. returns a reference
  4. each new = distinct identity
  5. no new = null reference

basics

~20 s

new makes a fresh object. It sets aside memory on the heap for the object, runs its constructor to set it up, and gives you back a reference (an address) you store in a variable.

solid answer

~40 s

The `new` keyword instantiates a class: it allocates memory on the heap for a new object of that type, initializes the object's fields (defaults first, then constructor logic), runs the matching constructor, and returns a reference to the freshly created object. That reference is what you assign to a variable. So `Dog d = new Dog();` creates a Dog on the heap and stores its reference in `d`. Without `new` you only have a reference variable that points to nothing (`null`); `new` is what actually produces the object the reference points at. Each `new` call yields a distinct object with its own identity and its own copy of instance fields.

code

java · 5 lines
java
Dog d;                 // reference variable, points to nothing yet (default null for a field)
d = new Dog();         // new: allocate on heap, run constructor, assign the reference to d
Dog a = new Dog();
Dog b = new Dog();
System.out.println(a == b); // false: two distinct objects, two distinct references

go deeper

for a junior

Knows new creates an object, calls a constructor, and you store the result in a variable.

for a middle

Explains the full sequence: heap allocation, default field init, constructor (with super and initializers), then a reference is returned and assigned.

for a senior

Distinguishes reference from object, notes identity per new, and mentions objects can be created without a literal new (literals, boxing, factories).

for a principal

Discusses allocation cost, escape analysis / scalar replacement letting the JIT avoid heap allocation, and TLAB (thread-local allocation buffers) for fast bump-pointer allocation.

## What "creating an object" means In Java, a **class** is a blueprint (a template describing what fields and methods an object has). An **object** (also called an *instance*) is a concrete thing built from that blueprint, living in memory at runtime. The act of building one object from a class is called **instantiation**. The **`new` keyword** is the operator that performs instantiation. When you write: ```java Dog d = new Dog(); ``` several distinct things happen, in order: 1. **Memory allocation.** The JVM (Java Virtual Machine — the program that runs your compiled Java) reserves a chunk of memory big enough to hold one `Dog` object. This memory comes from the **heap**, a large region of RAM the JVM manages for all objects. Allocation produces the raw object. 2. **Default field initialization.** Every instance field is first set to its *default* zero-value: numeric fields become `0`, `boolean` becomes `false`, and any reference field becomes `null`. This happens before any of your code runs, so a field is never "garbage". 3. **Constructor execution.** A **constructor** is a special method with the same name as the class and no return type; its job is to set up the new object. `new Dog()` calls the no-argument `Dog` constructor. Field initializers and instance-initializer blocks also run here, after the implicit `super(...)` call to the parent class constructor. 4. **Returning a reference.** Once the object is built, `new` evaluates to a **reference** — essentially the heap address (handle) of that object. That reference is the *value* of the `new` expression. The assignment `Dog d = ...` then stores that reference into the **reference variable** `d`. `d` is not the object; `d` holds a pointer-like handle to the object on the heap. ## Why `new` matters Without `new`, you can declare a reference variable (`Dog d;`) but it points to nothing — it is `null`, or unassigned. Trying to call a method through a `null` reference throws `NullPointerException`. `new` is the bridge from "a variable that could point to a Dog" to "an actual Dog exists". Every `new` call creates a **brand-new, distinct object** with its own **identity** and its own copy of all instance fields. So `new Dog()` and `new Dog()` are two different dogs even if their fields are equal. ## Things that are *not* `new` Not every object is born from a visible `new`: - String literals (`"hi"`) create String objects via the constant pool. - Autoboxing (`Integer x = 5;`) and array literals create objects. - Factory methods (`List.of(...)`, `Integer.valueOf(...)`) create or reuse objects internally. But conceptually they all do the same heap allocation + initialization that `new` does.

  • Where does the object created by `new` live, and where does the reference variable live?
    The object lives on the heap (shared, GC-managed). A local reference variable lives on the thread's stack and holds the handle to the heap object; an instance reference field lives inside its owning heap object.
  • Does `new` always return a different object than a previous `new` of the same type?
    Yes. Each `new` expression allocates a fresh object with its own identity, so `new T() == new T()` is always false (they are different references).

new is like ordering a custom-built house from a blueprint: the builder clears a plot (allocates memory), erects the standard frame (default fields), follows your spec sheet (constructor), and hands you the address (reference). The address slip is not the house.

saying these in an interview costs you the question

  • Saying `new` returns the object itself rather than a reference to it
  • Claiming the variable IS the object
  • Thinking `new` puts the object on the stack
  • Believing two `new` calls can return the same object

context

resolving links…