Nested and Inner Classes in Java: A Complete Beginner’s Guide

Learn nested and inner classes in Java the easy way. Static nested, inner, local, and anonymous classes explained with simple examples and interview tips.

1. Introduction

You write a class. Then you need a small helper class that only makes sense inside the first one. Where do you put it?

You could make a separate file for it. But that helper has no life on its own. It exists only to serve the class next to it. Putting it far away feels wrong.

Picture a real moment. You are building a shopping cart class. Inside it, you want a tiny structure to hold one line item, with a product and a quantity. That line item never gets used anywhere else. It has no reason to be a big public class in its own file.

This is where nested and inner classes in Java come in. Java lets you place one class right inside another. The helper lives where it belongs, close to the code that uses it.

1.1 What You Will Learn

In this guide, we start simple. We look at why Java allows classes inside classes. Then we walk through each kind, one at a time, with tiny examples.

Here is what we will cover:

• What a nested class is, and why you would want one
• Static nested classes, and how they stand apart
• Inner classes, and their link to the outer object
• Local classes, tucked inside a method
• Anonymous classes, made on the spot with no name
• A full walkthrough, common traps, and interview questions

By the end, you will know which type to pick and why. That is the real goal, not just naming the four kinds.

1.2 What You Need First

You only need to know basic Java classes and objects. If you can write a class and make an object from it, you are ready to go.

Do not treat this as a topic you memorize for a test. Nested classes show up all over the real Java world. The JDK itself uses them a lot, from Map.Entry inside Map to the iterators hidden in every collection. Once you learn the pattern, you start spotting it everywhere.

A small warning before we dive in. The names sound close, and beginners often mix them up. Take each type slowly, and the differences will settle in. There is no rush.

2. What Is a Nested Class?

A nested class is a class declared inside another class. The class on the outside is the outer class. The one tucked inside is the nested class.

Think of a car and its engine parts. A spark plug means little on its own. It only makes sense as a part of an engine. Some helper classes work the same way.

Java has allowed this since version 1.1. The feature is old and stable, so you can trust it fully. Every Java project you touch will likely use nested classes somewhere, even if you never wrote one yourself.

Here is the simplest form you can imagine:

public class Outer {
    // this is a nested class
    class Inner {
        void hello() {
            System.out.println("Hi from Inner");
        }
    }
}

That is it. One class, and another class living inside its curly braces. From here, the details branch out into a few flavors, and those flavors are what the rest of this guide unpacks.

2.1 Why Nest a Class at All?

You nest a class for one main reason. It belongs to the outer class and nowhere else. Keeping them together makes your code easier to read.

Here are the real wins you get:

• Grouping — related code sits in one place, not scattered across files.
• Cleaner packages — helper classes stay hidden inside their owner.
• Tighter access — a nested class can reach the outer class private members.
• Clear intent — the reader sees at once that the helper serves the outer class.

So a nested class is a tool for tidiness. It signals that two pieces of code are a team.

Take a real case. Say you build a LinkedList by hand. Each item needs a small Node holder, with a value and a link to the next node. That Node is useless anywhere else. Nesting it inside LinkedList keeps it hidden and close, exactly where it belongs.

Without nesting, you would have a loose Node class floating in your package. Other code could grab it by mistake. Nesting locks that door and keeps your design clean.

There is also a naming benefit. A top-level class must have a unique name in its package. A nested class only needs a name unique inside its outer class. So you can have Order.Item and Invoice.Item, and neither clashes with the other.

2.2 The Two Broad Families

Java splits nested classes into two groups. The word you look for is static.

• Static nested class — marked static. It does not need an outer object.
• Inner class — not marked static. It is tied to an outer object.

That single keyword changes a lot. A static nested class stands almost on its own. An inner class always rides along with an instance of the outer class.

The inner class family has three members. There is the regular inner class, the local class, and the anonymous class. We meet each one below.

A quick way to remember it: static means alone, no static means attached. If you can spot that one keyword, half the topic is already clear in your head.

2.3 A Map of the Four Types

It helps to see the whole set before we dig in. Here they are side by side:

Do not worry if this looks like a lot. We take them one by one, and each gets its own short example.

3. Static Nested Classes

Let us start with the easy one. A static nested class is a class inside a class, marked with static.

The static keyword does the heavy lifting here. It cuts the link to any outer object. The nested class stands on its own two feet.

3.1 It Does Not Need an Outer Object

A static nested class works without an instance of the outer class. You create it directly, using the outer class name as a prefix.

public class Computer {
    // static nested class
    static class USB {
        String model = "USB 3.0";
    }
}
 
// Creating it — no Computer object needed
Computer.USB usb = new Computer.USB();
System.out.println(usb.model); // Output: USB 3.0

See the syntax? You write Computer.USB and never make a Computer first. The nested class is reachable through the outer class name alone.

In many ways, a static nested class acts like a normal top-level class. The only real difference is where it sits and how you name it. You keep it inside the outer class for the sake of grouping, not because it needs the outer object.

You can even mark a static nested class private. Then only the outer class can use it. This is a neat way to hide a helper that the outside world should never see.

3.2 What It Can and Cannot Touch

A static nested class has limits on what it reaches. Since there is no outer object, it cannot use the outer instance fields.

• It can use the outer class static members, both fields and methods.
• It cannot use the outer class instance fields directly. There is no object to read them from.

This makes sense once you slow down. Instance fields belong to an object. With no object around, there is nothing to point at.

Here is a small example that shows the line clearly:

public class Config {
    static String appName = "MyApp";  // static
    String userId = "guest";          // instance
 
    static class Logger {
        void log() {
            System.out.println(appName); // OK: static field
            // System.out.println(userId); // ERROR: no instance
        }
    }
}

The Logger reads appName without trouble. But the userId line would fail to compile. There is no Config object for the Logger to borrow that field from.

3.3 A Realistic Use

A common pattern is a Builder. Many classes ship a static nested Builder to help you make objects step by step.

public class Pizza {
    private final String size;
 
    private Pizza(Builder b) {
        this.size = b.size;
    }
 
    // static nested builder
    static class Builder {
        private String size;
 
        Builder size(String s) {
            this.size = s;
            return this;
        }
 
        Pizza build() {
            return new Pizza(this);
        }
    }
}
 
Pizza p = new Pizza.Builder().size("Large").build();

The Builder lives inside Pizza because it serves only Pizza. It is static, so you use it without a Pizza object. Clean and self-contained.

Why is a static nested class the right fit here? A Builder does not need any state from a Pizza. In fact, it runs before a Pizza even exists. Its whole job is to gather values and then hand them over to build one. So it has no reason to hold an outer object.

You will see this exact pattern across many real libraries. When a helper works alongside a class but does not depend on a live instance of it, the static nested class is almost always the answer.

3.4 It Can Have Its Own Statics

A static nested class may hold its own static fields and methods. A plain inner class cannot, in most cases. This is another reason to reach for static when you can.

public class Server {
    static class Config {
        static int PORT = 8080;   // allowed
 
        static void printPort() {
            System.out.println(PORT);
        }
    }
}
 
Server.Config.printPort(); // Output: 8080

Here the Config class has a static PORT and a static method. You call them straight through the class name, with no object at all. That is a clean way to group related constants.

Try the same static field inside a non-static inner class, and the old Java rules push back. So if your helper needs its own statics, the static nested form is the natural home for it.

4. Inner Classes

Now we drop the static keyword. A plain inner class is tied to an object of the outer class. This bond is the whole point.

An inner class cannot exist without an outer instance. You make the outer object first, then the inner one hangs off it.

4.1 It Belongs to an Outer Object

Every inner class object holds a hidden link back to its outer object. Through that link, it can read everything the outer object has.

public class Engine {
    private String fuel = "Petrol";
 
    // inner class (no static)
    class Piston {
        void show() {
            // can reach outer private field directly
            System.out.println("Runs on " + fuel);
        }
    }
}

Look at the Piston. It reads fuel with no fuss, even though fuel is private. The hidden link makes that possible.

You can picture that link as an invisible field named Engine.this. It points from the inner object back to the outer one. You rarely write it out, but it is always there under the hood.

When two fields share a name, you can use it to be clear:

public class Engine {
    private String type = "V8";
 
    class Piston {
        private String type = "Steel";
 
        void show() {
            System.out.println(type);        // Steel (inner)
            System.out.println(Engine.this.type); // V8 (outer)
        }
    }
}

The plain type gives the inner field. The Engine.this.type form reaches out to the outer field. This spelling saves you when names clash.

4.2 Creating an Inner Class Object

The syntax trips up a lot of beginners. You need an outer object first. Then you use a special form to make the inner one.

Engine engine = new Engine();
Engine.Piston piston = engine.new Piston();
piston.show(); // Output: Runs on Petrol

Notice the odd bit: engine.new Piston(). You call new on the outer object, not on the class. That spelling looks strange the first time.

This is the key difference from a static nested class. There you wrote new Computer.USB(). Here you must go through a live object.

4.3 One Outer, Many Inner Objects

A single outer object can own many inner objects. Each inner object links back to that same outer instance. They all share its state.

But two different outer objects give you two separate worlds. An inner object from one outer cannot read the fields of a different outer. The link is fixed at creation and never moves.

This is why the engine.new syntax matters. It tells Java which outer object the inner one should attach to. The choice is locked in from that moment on.

You can picture it like a badge. Each inner object wears a badge naming its home outer object. It only opens the doors of that one home, never anyone else’s.

4.4 When It Shines

Inner classes fit when the helper truly needs the outer state. If the helper must read or change outer fields, an inner class is a clean fit.

A classic example is an iterator inside a collection. The iterator needs to walk the outer object data. An inner class gives it direct access.

Here is a tiny box that holds items and offers a counter for them:

public class Box {
    private String[] items = {"a", "b", "c"};
 
    class Counter {
        int howMany() {
            return items.length; // reads outer array
        }
    }
 
    Counter counter() {
        return new Counter();
    }
}
 
Box box = new Box();
System.out.println(box.counter().howMany()); // Output: 3

The Counter reaches straight into the items array. It never receives that array as a parameter. The inner-class link hands it over for free.

But be careful with one thing. Since the inner object holds the outer object alive, it can block garbage collection. We come back to this trap later.

4.5 Inner vs Static Nested, Side by Side

The two look almost the same in code. One keyword sets them apart, and that keyword changes how you use them. Let us put them next to each other.

Read that table slowly. Every row traces back to one thing: the hidden link. A static nested class drops the link, so it loses access to outer state but gains freedom. An inner class keeps the link, so it gains access but carries the outer object along.

5. Local Classes

Sometimes you need a class in just one method. Nowhere else. For that, Java offers the local class.

A local class is declared inside a method body. It lives and dies within that method. No other method can see it.

5.1 A Class Inside a Method

You write the class right in the middle of your code, like a variable. It only exists while that method runs.

public class Report {
    void generate() {
        // local class inside a method
        class Header {
            void print() {
                System.out.println("=== Report Header ===");
            }
        }
 
        Header h = new Header();
        h.print();
    }
}

The Header class is invisible outside generate(). It is a private tool for that one method. That is the whole idea.

You might ask when this ever beats a normal helper. The answer is scope. A local class keeps a helper truly local. No other method can call it by accident, and it does not clutter the class body.

In practice, local classes are rare. Most of the time a private method or a static nested class does the job with less fuss. Still, it is good to know the tool exists, because you will meet it in older code.

5.2 It Can Read Local Variables

A local class can use the local variables of its method. But there is a catch. Those variables must be final or effectively final.

Effectively final just means you never change the variable after you set it. Java treats it as final for you.

void greet(String name) {
    // 'name' is effectively final (never reassigned)
    class Greeter {
        void hello() {
            System.out.println("Hi, " + name);
        }
    }
    new Greeter().hello();
}

Here name is never changed, so the local class may read it. Try to reassign name later, and the compiler will complain.

This capture rule also applies to anonymous classes. Both types can freeze a snapshot of the method local variables. That is why you often pass values in and never touch them again.

5.3 Why the Final Rule Exists

You may wonder why the variable must stay final. The reason is quiet but simple.

The local object may outlive the method. So Java copies the variable value into the object. If the original could change, the two copies would drift apart. Java blocks that by forcing the value to stay put.

Think of it as a photocopy. The local class takes a photocopy of the value at capture time. Later edits to the original page would not show on the copy. To avoid that confusion, Java simply forbids the edits.

In real code, this rarely bites you. You usually read a value and leave it alone. But when the compiler does complain, now you know the reason behind it.

6. Anonymous Classes

The last type has no name at all. An anonymous class is a class you write and use in one shot, inline.

You use it when you need a one-off object. Naming a whole class would be overkill. So you skip the name and write it on the spot.

6.1 A Class With No Name

You create an anonymous class while making an object. It usually implements an interface or extends a class right there.

interface Greeting {
    void sayHello();
}
 
// anonymous class implementing Greeting
Greeting g = new Greeting() {
    public void sayHello() {
        System.out.println("Hello there!");
    }
};
 
g.sayHello(); // Output: Hello there!

There is no class name here. You write new Greeting() and then supply the body in braces. Java makes a hidden class for you behind the scenes.

If you peek at the compiled files, you will spot names like Outer$1.class. The number is Java giving the nameless class a label of its own. You never type that name, but the compiler needs one.

An anonymous class can also extend a real class, not just an interface:

Thread t = new Thread() {
    public void run() {
        System.out.println("Running in a thread");
    }
};
t.start();

Here the anonymous class extends Thread and overrides run(). You get a custom thread without writing a whole named subclass. That saves a lot of typing for a one-time need.

6.2 A Very Common Use

Anonymous classes show up a lot with listeners and callbacks. Old Java UI code used them heavily. You pass in behavior without a named class.

button.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked!");
    }
});

The listener runs only for this one button. It needs no name and no reuse. An anonymous class fits the job well.

You also see them in sorting, threading, and event handling. Anywhere you must hand over a small block of behavior, an anonymous class can carry it. It keeps the logic right next to where you use it, so the reader does not hunt around.

6.3 Anonymous Class vs Lambda

You may have seen lambdas doing similar work. A lambda is shorter, and it often replaces an anonymous class.

But there is a line between them. A lambda works only for a functional interface, which has one method. An anonymous class can do more, like extend a class or add fields.

We do not dig into lambdas here. Just know that an anonymous class is the older, more flexible tool. The lambda is the sleek modern shortcut for simple cases.

6.4 The Limits of Anonymous Classes

Anonymous classes are handy, but they come with real limits. Knowing them helps you decide when to reach for a named class instead.

• No constructor — you cannot give an anonymous class its own constructor, since it has no name to call.
• One base only — it can extend one class or implement one interface, not both at once.
• Hard to reuse — the class exists at one spot, so you cannot use it elsewhere.
• Harder to test — with no name, you cannot target it directly in a unit test.

So keep anonymous classes small and short-lived. The moment one grows fields, logic, and many methods, it is begging to become a proper named class. Give it a name and a home.

7. Access and the Enclosing Class

One big perk runs through all these types. A nested class can reach the private members of its outer class. Let us look closer, because this is a point that surprises many people.

7.1 Nested Classes Break the Private Wall

Normally, private means hidden from the outside. But a nested class is not really outside. It sits within the outer class.

public class Bank {
    private double balance = 500.0;
 
    class Account {
        void show() {
            // reads outer private field freely
            System.out.println("Balance: " + balance);
        }
    }
}

The Account class reads balance with ease. The private keyword does not block it. To Java, they are family.

7.2 The Outer Class Reads the Nested One Too

The access goes both ways. The outer class can also reach the private members of its nested class.

public class Wallet {
    private Card card = new Card();
 
    private class Card {
        private String number = "1234";
    }
 
    void show() {
        // outer reads the nested private field
        System.out.println(card.number);
    }
}

The Wallet reads card.number even though number is private. To Java, the outer and nested classes are one unit. Private walls do not stand between them.

So the two classes share a trust bond. This is why nested classes are great for helpers that need close cooperation.

There is a design lesson hiding here. Because a nested class can see private outer state, it can break your encapsulation if you are careless. Keep the nested class focused. Let it touch only what it truly needs, and no more.

8. A Practical Walkthrough

Let us tie it all together with one small, realistic build. Say you write a tiny music playlist. It holds songs and hands out a player and a shuffle helper.

We will use two nested types here. One needs the playlist data, so it will be an inner class. The other does not, so it will be static. Watch how the choice falls out of the need.

8.1 The Outer Class and Its Data

First, the Playlist itself. It keeps a simple list of song names. Nothing fancy, just a place to hold state.

public class Playlist {
    private String[] songs;
    private int current = 0;
 
    public Playlist(String[] songs) {
        this.songs = songs;
    }
}

The songs array and the current index are private. Only the Playlist should touch them directly. Now we add helpers that lean on this state.

8.2 An Inner Class That Needs the State

A Player must read the song list and track the current song. It cannot work without the Playlist data. So an inner class fits it well.

class Player {
    void playNext() {
        if (current < songs.length) {
            System.out.println("Playing: " + songs[current]);
            current++;
        } else {
            System.out.println("End of playlist");
        }
    }
}

See how Player reads songs and current with no fuss. It never takes them as parameters. The inner-class link hands the outer state straight to it.

You create the Player through a live Playlist object, like this:

Playlist list = new Playlist(new String[]{"Song A", "Song B"});
Playlist.Player player = list.new Player();
player.playNext(); // Output: Playing: Song A
player.playNext(); // Output: Playing: Song B

The player moves through the songs and updates the shared index. Two calls, two songs. The state lives in the Playlist, and the inner Player rides along with it.

8.3 A Static Nested Helper That Does Not

Now add a helper that shuffles an array. This helper does not care about any one Playlist. It just takes an array and mixes it. So it should be static.

static class Shuffler {
    static void shuffle(String[] arr) {
        for (int i = arr.length - 1; i > 0; i--) {
            int j = (int) (Math.random() * (i + 1));
            String tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
        }
    }
}

The Shuffler needs no Playlist object. You call it straight through the class name. It is a pure tool, grouped inside Playlist only because it belongs to that world.

String[] tracks = {"A", "B", "C"};
Playlist.Shuffler.shuffle(tracks); // no Playlist object needed

8.4 What This Teaches

Look back at the two helpers. The Player reads outer state, so it stayed non-static. The Shuffler did not, so it went static. You did not force the choice. The need made it for you.

This is the mindset to carry forward. Do not start by picking a type. Start by asking what the helper needs. The right nested class then shows up on its own.

Notice one more thing. Both helpers lived inside Playlist, close to the data they served. A reader opening this file sees the whole design in one place. That closeness is the quiet gift of nested classes.

9. Common Mistakes and Pitfalls

A few traps catch beginners over and over. Let us name them so you can steer clear.

9.1 Forgetting the Outer Object for Inner Classes

People often try new Piston() straight away. That fails for an inner class. You must write outer.new Piston() through a live outer object.

The error message can look confusing at first. Java complains that it cannot find an enclosing instance. Once you know the rule, the message makes sense. The inner class wants an outer object, and you gave it none.

9.2 Mixing Up Static Nested and Inner

The static keyword is easy to drop or add by mistake. Remember the rule. With static, no outer object is needed. Without it, an outer object is a must.

A stray static can also change meaning in a quiet way. Your code may still compile, but the class stops sharing the outer state you expected. Read the keyword twice when a nested class acts oddly.

9.3 Trying to Reassign Captured Variables

In a local or anonymous class, a used local variable must stay effectively final. Change it after capture, and the code will not compile. Keep captured variables read-only.

A common slip is a loop counter. You cannot use a changing loop variable inside an anonymous class from an old-style for loop. Copy it into a fresh final variable first, then capture that copy.

9.4 Memory Leaks From Inner Classes

An inner class object keeps its outer object alive. If the inner one lives long, the outer one cannot be collected. In big apps this leaks memory.

Picture a large screen object that hands out a small inner listener. If some long-lived cache holds that listener, it also pins the whole screen in memory. The screen sticks around long after you close it.

The fix is simple. Prefer a static nested class when you do not need the outer state. Without the hidden link, the outer object is free to go once you are done with it.

9.5 Nesting Too Deep

You can nest a class inside a nested class inside another class. Java allows it. But your reader will suffer. Deep nesting turns simple code into a maze.

Keep it shallow. One level of nesting is common and clear. Two levels is the rare exception. If you go deeper, that is a sign to pull a class out into its own file.

The same caution applies to size. A nested class should stay small and focused. When it grows into a big class with many methods, it stops feeling like a helper. At that point, give it its own file and let it breathe.

10. When to Use Which

So which type do you pick? Here is a plain guide you can lean on.

10.1 A Quick Decision List

• No need for outer state? Use a static nested class. It is the lightest choice.
• Need to read or change outer fields? Use a plain inner class.
• Need a helper in just one method? Use a local class.
• Need a quick one-off object for an interface? Use an anonymous class or a lambda.

When in doubt, lean toward the static nested class. It avoids the hidden link and the memory trap that comes with it.

Notice a pattern in that list. You only give up static when you truly need the outer object. So the question to ask is plain: does this helper read outer instance state? If not, keep it static and sleep easy.

10.2 A Side-by-Side Recap

Here is the full picture once more, now with a hint on when each fits:

Keep this near you as a cheat sheet. Over time, the right pick will feel natural.

One last tip on choosing. When two options both seem to work, pick the simpler one. A static nested class is simpler than an inner class, because it drops the hidden link. So it wins any tie by default.

11. Interview Questions

12. Conclusion

Let us wrap up what we covered. Nested and inner classes in Java let you place one class inside another, close to where it belongs.

A static nested class stands alone and needs no outer object. The plain inner class rides along with an outer instance and can read its state. Local and anonymous classes handle the small, one-time jobs, one inside a method and one with no name at all.

Reach for the static nested class by default. Move to an inner class only when you truly need the outer object. Use local and anonymous classes for small, one-time jobs.

Do not stress about memorizing every rule right now. The one idea that carries you far is the static split. Static means alone, no static means attached to an outer object. Hold that thought, and the rest falls out of it.

Remember the lesson from the playlist walkthrough too. You did not pick a type first. You asked what each helper needed, and the right type showed up on its own. Carry that habit into your own code.

Play with each type in a small project. Write a builder, then an iterator, then a quick listener. Once you feel the difference between static and non-static by hand, the whole topic clicks into place.

Further Reading

• Understanding the static Keyword in Java
• this and super Keywords in Java Explained
• Object Class Methods in Java: equals, hashCode, toString
• Oracle Javadoc: Nested Classes (The Java Tutorials)