In Java, classes are usually defined separately.
But sometimes, it makes logical sense to define a class inside another class 🧩

This concept is called Nested Classes.

Nested classes improve:

• Code organization 📦
• Logical grouping 🧠
• Encapsulation 🔒
• Readability ✨

Java provides powerful mechanisms to create classes within classes, and understanding them deeply helps in writing structured and professional code.

This article explains Nested Classes and Inner Classes in Java in complete detail — with clear examples, step-by-step explanations, and common pitfalls.

---

🧠 What Is a Nested Class?

A Nested Class is a class defined inside another class.

There are two main types:

1️⃣ Static Nested Class
2️⃣ Inner Class (Non-static Nested Class)

Additionally, Java also supports:
3️⃣ Local Inner Class
4️⃣ Anonymous Inner Class

---

🏗️ 1️⃣ Static Nested Class

A static nested class is declared using the static keyword.

Key Characteristics:

• Belongs to outer class
• Does NOT require outer object
• Can access only static members of outer class directly

---

▶️ Example 1: Static Nested Class

class Outer {

    static int x = 10;

    static class Inner {
        void display() {
            System.out.println("Value of x: " + x);
        }
    }
}

public class StaticNestedDemo {
    public static void main(String[] args) {

        Outer.Inner obj = new Outer.Inner();
        obj.display();
    }
}

---

🧠 Step-by-Step Explanation

• Outer is outer class
• Inner is static nested class
• x is static variable
• Inner accesses x directly
• No Outer object required

🖨 Output:

Value of x: 10

---

⚠️ Important Rule

Static nested class:

• Cannot access non-static members directly ❌

---

🏗️ 2️⃣ Non-Static Inner Class

A non-static nested class is simply called an Inner Class.

Key Characteristics:

• Requires outer class object
• Can access all members (including private)
• Associated with specific outer object

---

▶️ Example 2: Inner Class

class Outer {

    int x = 20;

    class Inner {
        void display() {
            System.out.println("Value of x: " + x);
        }
    }
}

public class InnerClassDemo {
    public static void main(String[] args) {

        Outer outerObj = new Outer();
        Outer.Inner innerObj = outerObj.new Inner();

        innerObj.display();
    }
}

---

🧠 Step-by-Step Explanation

1️⃣ Outer object is created
2️⃣ Inner object created using outerObj.new Inner()
3️⃣ Inner class accesses outer variable x
4️⃣ Output displayed

🖨 Output:

Value of x: 20

---

🔍 Why Does Inner Class Need Outer Object?

Because:

• Inner class is associated with specific outer instance
• It can access non-static members

---

🧠 Memory Concept

For Inner Class:

• Each inner object is tied to outer object
• Cannot exist independently

For Static Nested Class:

• Acts like normal class
• No outer reference stored

---

🏗️ 3️⃣ Local Inner Class

A class defined inside a method.

---

▶️ Example 3: Local Inner Class

class Outer {

    void show() {

        class LocalInner {
            void display() {
                System.out.println("Inside Local Inner Class");
            }
        }

        LocalInner obj = new LocalInner();
        obj.display();
    }
}

public class LocalInnerDemo {
    public static void main(String[] args) {

        Outer o = new Outer();
        o.show();
    }
}

---

🧠 Explanation

• LocalInner exists only inside show()
• Cannot be accessed outside method
• Scope limited to method block

---

🏗️ 4️⃣ Anonymous Inner Class

A class without a name.

Used mainly for:

• Implementing interfaces
• Overriding methods

---

▶️ Example 4: Anonymous Inner Class

abstract class Greeting {
    abstract void sayHello();
}

public class AnonymousInnerDemo {
    public static void main(String[] args) {

        Greeting g = new Greeting() {
            void sayHello() {
                System.out.println("Hello from Anonymous Class");
            }
        };

        g.sayHello();
    }
}

---

🧠 Explanation

• Anonymous class extends Greeting
• Provides implementation
• No separate class definition required
• Used once

---

📊 Summary Table

Type	Requires Outer Object	Can Access Private Members	Typical Use
Static Nested	❌	Only static	Utility grouping
Inner Class	✅	Yes	Strong coupling
Local Inner	✅	Yes	Method-level logic
Anonymous	Depends	Yes	Quick implementation

---

❓ Common Confusions

❓ Is inner class same as static nested class?

❌ No
Static nested class behaves like normal class.

---

❓ Can inner class have static members?

❌ Only if they are constants.

---

❓ Can outer class access inner members?

Yes, if object exists.

---

❌ Common Mistakes

❌ Forgetting outer object for inner class

Outer.Inner obj = new Outer.Inner(); // ❌ ERROR

Correct:

Outer outerObj = new Outer();
Outer.Inner obj = outerObj.new Inner();

---

❌ Trying to access non-static member in static nested class

Compilation error ❌

---

❌ Overusing inner classes unnecessarily

Can make code confusing.

---

🧪 Tricky Example

class Outer {

    int x = 5;

    class Inner {
        int x = 10;

        void display() {
            System.out.println(x);
            System.out.println(Outer.this.x);
        }
    }
}

public class TrickyInnerDemo {
    public static void main(String[] args) {

        Outer o = new Outer();
        Outer.Inner i = o.new Inner();
        i.display();
    }
}

🖨 Output:

10
5

🧠 Explanation

• x refers to inner variable
• Outer.this.x refers to outer variable

---

🎯 Best Practices

• Use nested classes for logical grouping
• Use static nested class when no outer instance needed
• Avoid unnecessary complexity
• Keep design simple and readable

---

✅ Conclusion

Nested and inner classes provide powerful tools for organizing and structuring Java code 🚀

By understanding:

• Static nested classes
• Non-static inner classes
• Local inner classes
• Anonymous inner classes
• Object relationships and memory behavior

You gain deeper control over class design and encapsulation 💪

When used appropriately, nested classes enhance clarity and maintainability.
When misused, they increase confusion.

Mastery of this topic strengthens understanding of advanced features such as:

• Event handling
• GUI programming
• Functional programming concepts