`new` Operator in Java

The new operator is one of the first Java keywords every developer learns. Every time you create an object, you're using new.

But what actually happens behind the scenes?

Where is the object created? Why doesn't Java have a delete operator like C++? What's the difference between new and reflection-based object creation?

In this article, we'll answer all of these questions with simple explanations and practical examples.

What is the `new` Operator?

The new operator is used to create objects in Java.

Every object in Java is created using new (except for a few special cases like string literals and certain JVM optimizations).

Two Important Facts

The new operator creates an object.
Java does not have a delete operator. Unused objects are automatically removed by the Garbage Collector (GC).

Syntax

ClassName reference = new ClassName();

Examples

Creating a String

String name = new String("Rajesh");

Creating a Thread

Thread thread = new Thread();

Creating Your Own Class

Test obj = new Test();

What Happens When You Use `new`?

When Java executes

Test obj = new Test();

three things happen:

Memory is allocated on the Heap.
The constructor is invoked to initialize the object.
A reference to the newly created object is returned.

Test obj = new Test();
//         ↑
//     Object created on Heap

//                  ↑
//          Constructor executed

//  Reference returned and stored in obj

Where Are Objects Created?

Objects created using new are stored in the Heap Memory.

The reference variable itself is usually stored in the current method's stack frame (for local variables), while the object lives on the heap.

Stack Memory                Heap Memory

obj  ───────────────►   Test Object

Why Doesn't Java Have a `delete` Operator?

Unlike C++, Java automatically manages memory.

In C++:

Programmer creates objects using new.
Programmer must manually destroy them using delete.

If the programmer forgets to call delete, memory leaks occur.

Java vs C++

Feature	Java	C++
Create object	`new`	`new`
Destroy object	Garbage Collector	`delete`
Memory management	Automatic	Manual

Java's automatic memory management reduces:

Memory leaks
Dangling pointers
Double deletion errors
Many application crashes

What is Garbage Collection?

The Garbage Collector (GC) automatically removes objects that are no longer being used.

Programmers create objects.

The JVM decides when unused objects should be destroyed.

When Is an Object Eligible for Garbage Collection?

An object becomes eligible for garbage collection when no live references point to it.

Eligible does not mean it is immediately removed. The JVM decides when to run the Garbage Collector.

Method 1: Assign `null`

String name = new String("Rajesh");

name = null;

The object has no references now and becomes eligible for GC.

Method 2: Reassign the Reference

String name = new String("Rajesh");

name = new String("Bhola");

Now:

The first String object has no references.
It becomes eligible for GC.
The second object is referenced by name.

Method 3: Local Objects Going Out of Scope

public void display() {

    Test obj = new Test();

}

When the method finishes,

obj goes out of scope.

If no other reference exists, the object becomes eligible for GC.

`new` vs Reflection-Based Object Creation

There are two common ways to create objects.

1. Using `new`

Test obj = new Test();

The class name is known during compilation.

2. Using Reflection

Sometimes the class name isn't known until runtime.

Example:

Object obj =
        Class.forName("com.example.Test")
             .getDeclaredConstructor()
             .newInstance();

Here, Java creates the object dynamically.

This technique is heavily used by frameworks.

Why Was `Class.newInstance()` Deprecated?

Older Java versions used:

Class.forName("Test").newInstance();

This method has been deprecated since Java 9 because it has poor exception handling.

Modern Java recommends:

Object obj =
        Class.forName("Test")
             .getDeclaredConstructor()
             .newInstance();

This approach provides clearer and safer exception handling.

For modern Java development, always prefer Constructor::newInstance() over Class::newInstance().

Dynamic Object Creation Example

public class Test {

    public static void main(String[] args) throws Exception {

        Object obj =
                Class.forName(args[0])
                     .getDeclaredConstructor()
                     .newInstance();

        System.out.println(obj.getClass().getName());
    }
}

Run:

java Test java.lang.String

Output

java.lang.String

Run:

java Test java.lang.Thread

Output

java.lang.Thread

The class is chosen at runtime.

`new` vs Reflection

Feature	`new`	Reflection (`newInstance`)
Type	Operator	Method
Class name known	Compile time	Runtime
Constructor called	Any accessible constructor	Constructor obtained via reflection
Used in	Normal programming	Frameworks, plugins, dependency injection

Common Exceptions

Using `new`

Test obj = new Test();

If the class was present during compilation but missing at runtime, Java throws:

NoClassDefFoundError

This is an unchecked error.

Using Reflection

Class.forName("Test");

If the class cannot be found, Java throws:

ClassNotFoundException

This is a checked exception.

`ClassNotFoundException` vs `NoClassDefFoundError`

Feature	`ClassNotFoundException`	`NoClassDefFoundError`
Type	Checked Exception	Unchecked Error
Occurs with	`Class.forName()`	`new`
Reason	Class not found during dynamic loading	Class available at compile time but missing at runtime

Where Is Reflection Used?

Reflection-based object creation is widely used in:

Spring Framework
Hibernate
Dependency Injection
Plugin architectures
JDBC Driver Loading
Serialization libraries

Example:

Class.forName("com.mysql.cj.jdbc.Driver");

Although modern JDBC drivers are auto-loaded, this statement is still a popular interview topic.

Summary Table

Feature	`new` Operator
Purpose	Creates objects
Memory location	Heap
Calls constructor	✅ Yes
Returns	Object reference
Object destruction	Garbage Collector
`delete` operator available?	❌ No

Interview Questions

What does the `new` operator do?

It allocates memory on the heap, invokes the constructor, and returns an object reference.

Where are objects created?

On the Heap.

Does Java have a `delete` operator?

No.

Object destruction is handled automatically by the Garbage Collector.

When is an object eligible for Garbage Collection?

When no live references point to it.

What is the difference between `new` and reflection?

new is used when the class is known at compile time.
Reflection is used when the class is determined at runtime.

Why is `Class.newInstance()` deprecated?

Because it doesn't handle constructor exceptions properly.

Use:

getDeclaredConstructor().newInstance()

instead.

Memory Tricks 🧠

`new`

You know the class today.

Test obj = new Test();

Reflection

You'll decide the class later.

Class.forName(className)

Garbage Collection

No references = Eligible for GC

(Remember: eligible doesn't mean immediately collected.)

Easy Way to Remember

new creates. GC destroys.

You create objects.

The JVM cleans them up automatically when they're no longer reachable.

Key Takeaways

The new operator creates objects by allocating memory on the heap, invoking the constructor, and returning a reference.
Java has no delete operator because the Garbage Collector automatically reclaims memory occupied by unreachable objects.
An object becomes eligible for garbage collection when no live references point to it, although the JVM decides when collection actually occurs.
Reflection allows objects to be created dynamically when the class name is known only at runtime.
Class.newInstance() is deprecated; modern Java uses getDeclaredConstructor().newInstance() for reflective object creation.
Understanding object creation, heap memory, garbage collection, and reflection is essential for writing efficient Java applications and succeeding in interviews.

Happy Coding!