The new Keyword in Java

The new keyword in Java creates objects. Every time you write new Something(), Java builds a fresh object in memory and hands you a way to reach it. It looks like a single step, but four things happen behind the scenes, and knowing them explains many common Java bugs.

What does new do in Java?

A class is only a blueprint. new is the builder that turns the blueprint into a real object you can use:

Book book = new Book("Dune", 412);

• Book book — declares a variable that can hold a reference to a Book.
• new Book("Dune", 412) — creates the object and runs its constructor with those arguments.
• = — stores the reference in book.

What happens step by step when you call new?

Local variables inside methods don't get defaults. Java makes you assign them before use.

Let's see it in action

class Book {
    String title;
    int pages;
    boolean borrowed;

    Book() { }                          // leaves the defaults alone

    Book(String title, int pages) {
        this.title = title;
        this.pages = pages;
    }
}

Book blank = new Book();
Book dune  = new Book("Dune", 412);

System.out.println(blank.title + ", " + blank.pages + ", " + blank.borrowed);
System.out.println(dune.title + ", " + dune.pages + ", " + dune.borrowed);

null, 0, false
Dune, 412, false

Using new to create arrays

Arrays are objects too, so they're also created with new:

int[] scores = new int[3];                 // [0, 0, 0] — defaults again
String[] names = new String[2];            // [null, null]
int[] primes = new int[] {2, 3, 5, 7};     // create and fill
int[] evens = {2, 4, 6};                   // shorthand, only when declaring

System.out.println(java.util.Arrays.toString(scores));

[0, 0, 0]

String literal vs new String(): a classic interview question

String a = "hello";
String b = "hello";
String c = new String("hello");

System.out.println(a == b);        // same pooled object?
System.out.println(a == c);        // c is a separate copy
System.out.println(a.equals(c));   // same characters?

true
false
true

String literals are stored once in Java's string pool and reused, so a and b share an object. new String(...) always makes a new copy. The lesson: compare strings with equals(), never ==, and you'll rarely need new String(...).

Do you always need new?

No. Modern Java often hides new behind factory methods, which are static methods that create objects for you:

Runnable task = new Runnable() {     // anonymous class
    @Override
    public void run() {
        System.out.println("Running!");
    }
};

Runnable sameTask = () -> System.out.println("Running!");   // lambda: same thing, shorter

What happens to objects you no longer use?

Java cleans up for you. When no variable refers to an object anymore, it becomes eligible for garbage collection and its memory is reclaimed automatically. There's no delete in Java. Calling new inside a tight loop is fine for small objects; modern garbage collectors are very fast.

Quick recap

What's next?

Objects can fail too. Learn how Java signals errors in throw vs throws, or revisit classes and objects.