Java Notes

Inner Class in Java

Complete guide to inner classes in Java — member inner classes, static nested classes, local inner classes, and when to use each type for better encapsulation and code organization.

An inner class is a class defined inside another class. Java supports four types of nested classes, each with different access rules and use cases. Inner classes are powerful for encapsulating helper types that only make sense in the context of their enclosing class.

Types of Nested Classes

Type	Declared	Has access to outer instance?	Use case
Member Inner Class	Inside class body	✅ Yes	Tightly coupled helper
Static Nested Class	Inside class with `static`	❌ No	Independent helper
Local Inner Class	Inside a method	✅ Yes + local vars	One-method helper
Anonymous Inner Class	Inline (no name)	✅ Yes + local vars	One-time implementation

1. Member Inner Class

A non-static class defined inside another class. It has access to ALL members of the outer class, including private:

Example

public class LinkedList { private Node head; private int size; // Member inner class — tightly coupled to LinkedList private class Node { int data; Node next; Node(int data) { this.data = data; this.next = null; } } public void addFirst(int data) { Node newNode = new Node(data); newNode.next = head; head = newNode; size++; } public void addLast(int data) { Node newNode = new Node(data); if (head == null) { head = newNode; } else { Node current = head; while (current.next != null) { current = current.next; } current.next = newNode; } size++; } public void display() { Node current = head; System.out.print("LinkedList [" + size + "]: "); while (current != null) { System.out.print(current.data + " -> "); current = current.next; } System.out.println("null"); } // Inner class that accesses outer class's private members public class Iterator { private Node current = head; // Accesses outer's private 'head' public boolean hasNext() { return current != null; } public int next() { if (current == null) throw new RuntimeException("No more elements"); int data = current.data; current = current.next; return data; } } public Iterator iterator() { return new Iterator(); } } public class Main { public static void main(String[] args) { LinkedList list = new LinkedList(); list.addLast(10); list.addLast(20); list.addLast(30); list.addFirst(5); list.display(); // Using the inner Iterator class LinkedList.Iterator it = list.iterator(); System.out.print("Iterating: "); while (it.hasNext()) { System.out.print(it.next() + " "); } System.out.println(); } }

Output

LinkedList [4]: 5 -> 10 -> 20 -> 30 -> null
Iterating: 5 10 20 30

Creating a Member Inner Class Object

java example

// From outside the outer class:
LinkedList list = new LinkedList();
LinkedList.Iterator iter = list.iterator();      // Via factory method (preferred)
LinkedList.Iterator iter2 = list.new Iterator(); // Direct instantiation (less common)

2. Static Nested Class

A nested class with static modifier. It does NOT have access to the outer class's instance members:

Example

public class Database { private String url; private String username; // Static nested class — doesn't need Database instance public static class ConnectionConfig { private String host; private int port; private String dbName; private int poolSize; private int timeout; public ConnectionConfig(String host, int port, String dbName) { this.host = host; this.port = port; this.dbName = dbName; this.poolSize = 5; this.timeout = 30000; } public ConnectionConfig setPoolSize(int poolSize) { this.poolSize = poolSize; return this; } public ConnectionConfig setTimeout(int timeout) { this.timeout = timeout; return this; } public String getConnectionUrl() { return "jdbc:mysql://" + host + ":" + port + "/" + dbName; } @Override public String toString() { return getConnectionUrl() + " [pool=" + poolSize + ", timeout=" + timeout + "ms]"; } } public Database(ConnectionConfig config) { this.url = config.getConnectionUrl(); System.out.println("Connected to: " + config); } public void query(String sql) { System.out.println("Executing on " + url + ": " + sql); } } public class Main { public static void main(String[] args) { // Create static nested class without outer instance Database.ConnectionConfig config = new Database.ConnectionConfig("localhost", 3306, "myapp") .setPoolSize(10) .setTimeout(5000); Database db = new Database(config); db.query("SELECT * FROM users"); } }

Output

Connected to: jdbc:mysql://localhost:3306/myapp [pool=10, timeout=5000ms]
Executing on jdbc:mysql://localhost:3306/myapp: SELECT * FROM users

3. Local Inner Class

Defined inside a method — limited scope, can access outer class members and effectively final local variables:

java example

public class ReportGenerator {
    private String companyName = "TechCorp";

    public void generateReport(String[] data, String reportType) {
        // Local inner class — exists only within this method
        class ReportFormatter {
            private String header;

            ReportFormatter(String header) {
                this.header = header;
            }

            void printReport() {
                System.out.println("=== " + header + " ===");
                System.out.println("Company: " + companyName);  // Accesses outer field
                System.out.println("Type: " + reportType);  // Accesses method parameter
                for (String item : data) {
                    System.out.println("  • " + item);
                }
                System.out.println("==================");
            }
        }

        ReportFormatter formatter = new ReportFormatter("Q4 Report");
        formatter.printReport();
    }
}

public class Main {
    public static void main(String[] args) {
        ReportGenerator gen = new ReportGenerator();
        gen.generateReport(
            new String[]{"Revenue: $1.2M", "Growth: 15%", "New Clients: 23"},
            "Quarterly Summary"
        );
    }
}

Output

=== Q4 Report ===
Company: TechCorp
Type: Quarterly Summary
  • Revenue: $1.2M
  • Growth: 15%
  • New Clients: 23
==================

Member Inner vs Static Nested — When to Use

java example

public class Outer {
    private int outerField = 42;

    // MEMBER inner class — needs outer instance
    class Inner {
        void accessOuter() {
            System.out.println("Outer field: " + outerField);  // ✅ Can access
            System.out.println("Outer this: " + Outer.this);   // ✅ Has reference
        }
    }

    // STATIC nested class — independent
    static class StaticNested {
        void tryAccessOuter() {
            // System.out.println(outerField);  // ❌ Cannot access!
            // System.out.println(Outer.this);  // ❌ No outer reference!
            System.out.println("I'm independent of any Outer instance");
        }
    }
}

Use Member Inner Class When:

The inner class needs access to the outer class's instance state
The inner class logically belongs to a specific instance
Example: Iterator for a collection

Use Static Nested Class When:

The inner class is logically related but doesn't need outer state
You want it to be instantiated independently
Example: Builder, Configuration, Node (in some cases)

Real-World Pattern: Builder with Static Nested Class

Example

public class HttpRequest { private final String method; private final String url; private final Map<String, String> headers; private final String body; private final int timeout; // Private constructor — only Builder can create private HttpRequest(Builder builder) { this.method = builder.method; this.url = builder.url; this.headers = Collections.unmodifiableMap(builder.headers); this.body = builder.body; this.timeout = builder.timeout; } @Override public String toString() { return method + " " + url + " [headers=" + headers.size() + ", timeout=" + timeout + "ms]" + (body != null ? "\nBody: " + body : ""); } // Static nested Builder class public static class Builder { private String method = "GET"; private String url; private Map<String, String> headers = new HashMap<>(); private String body; private int timeout = 30000; public Builder(String url) { this.url = url; } public Builder method(String method) { this.method = method; return this; } public Builder header(String key, String value) { headers.put(key, value); return this; } public Builder body(String body) { this.body = body; return this; } public Builder timeout(int timeout) { this.timeout = timeout; return this; } public HttpRequest build() { if (url == null) throw new IllegalStateException("URL is required"); return new HttpRequest(this); } } } public class Main { public static void main(String[] args) { HttpRequest request = new HttpRequest.Builder("https://api.example.com/users") .method("POST") .header("Content-Type", "application/json") .header("Authorization", "Bearer token123") .body("{\"name\": \"Alice\", \"age\": 30}") .timeout(5000) .build(); System.out.println(request); } }

Output

POST https://api.example.com/users [headers=2, timeout=5000ms]
Body: {"name": "Alice", "age": 30}

Common Mistakes

Trying to instantiate member inner class without outer:

``java // Inner inner = new Inner(); // ❌ Needs an outer instance Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); // ✅ ``

Memory leak with inner classes:

``java // Member inner class holds a reference to outer class // If inner lives longer than outer, outer can't be garbage collected! ``

Modifying local variables in local inner class:

``java int count = 0; class Local { void increment() { count++; // ❌ Must be effectively final! } } ``

Using member inner class when static would work:

``java // If the inner class doesn't use outer's instance fields, // make it static to avoid carrying an unnecessary reference. ``

Best Practices

Use static nested for Builder pattern and configuration classes
Use member inner classes for iterators and event handlers
Make inner classes private unless external access is needed
Prefer static nested over member inner to avoid hidden references
Keep inner classes small — if it grows large, extract to top-level
Watch for memory leaks with non-static inner classes in Android/long-lived contexts

Interview Questions

Q1: What is the difference between inner class and static nested class? Inner class has implicit reference to outer instance (can access instance members). Static nested class does not (independent, accessed like a regular class).

Q2: Can an inner class access private members of the outer class? Yes. Member inner classes can access ALL members (including private) of the enclosing class.

Q3: Can we have a static method in a member inner class? No (prior to Java 16). Only static nested classes can have static members. Java 16+ relaxes this rule.

Q4: Why does Java allow inner classes? For better encapsulation and logical grouping. Helper classes that only make sense in the context of another class can be nested inside it.

Q5: What is the hidden reference in member inner classes? Every member inner class instance holds an implicit reference to its enclosing outer class instance. This is how it accesses outer members.

Q6: How do you access the outer class's this from an inner class? Use OuterClassName.this to get the outer class instance reference.

Q7: Can a local inner class access local variables? Only if they are effectively final (not modified after initialization). This is because the inner class may outlive the method, and local variables are on the stack.

Q8: What is the memory implication of non-static inner classes? Each non-static inner class instance holds a hidden reference to its outer class instance. This means the outer object cannot be garbage collected as long as the inner class instance exists. This can cause memory leaks, especially in Android development with Activity references.

Q9: Can an inner class extend another class or implement an interface? Yes. Inner classes are full classes — they can extend any class, implement interfaces, be abstract, or be final. class Outer { class Inner extends SomeClass implements SomeInterface { } } is perfectly valid.

Q10: What is a local inner class? When is it used? A local inner class is defined inside a method body. It's visible only within that method. It can access the enclosing method's local variables only if they're effectively final. Use case: when you need a class for a one-time purpose within a specific method.

Q11: How do you instantiate a non-static inner class from outside the outer class? You need an outer class instance first: Outer outer = new Outer(); Outer.Inner inner = outer.new Inner();. The new keyword is used on the outer instance because the inner class needs a reference to its enclosing object.

Q12: What is the difference between inner class and composition? Inner classes have privileged access to the outer class's private members and exist within the outer class's scope. Composition (class Car { private Engine engine; }) creates a has-a relationship between independent classes with no special access privileges.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Inner Class in Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, oops, inner, class

Continue learning this concept

OOPsAbstract Class in JavaComplete guide to abstract classes in Java — abstract methods, partial implementation, when to use abstract classes, template method pattern, and abstract class vs interface comparison.OOPsAnonymous Class in JavaComplete guide to anonymous classes in Java — creating inline implementations, event handlers, comparators, and understanding when lambdas replaced anonymous classes.OOPsClass and Object in JavaDeep dive into Java classes and objects — class anatomy, object creation, memory allocation, instance vs class members, and how objects work under the hood in the JVM.OOPsObject Class in JavaComplete guide to the java.lang.Object class — toString(), equals(), hashCode(), clone(), getClass(), finalize(), and how every Java class inherits from Object.OOPsWrapper Class in JavaComplete guide to wrapper classes in Java — autoboxing, unboxing, primitive to object conversion, number parsing, caching, and when to use primitives vs wrappers.OOPsAbstraction in JavaComplete guide to abstraction in Java — hiding complexity, abstract classes and interfaces, abstraction layers, real-world design, and achieving loose coupling through abstraction.

PreviousInheritance in Java NextInterface in Java

Java Notes

Inner Class in Java

Complete guide to inner classes in Java — member inner classes, static nested classes, local inner classes, and when to use each type for better encapsulation and code organization.

Types of Nested Classes

Type	Declared	Has access to outer instance?	Use case
Member Inner Class	Inside class body	✅ Yes	Tightly coupled helper
Static Nested Class	Inside class with `static`	❌ No	Independent helper
Local Inner Class	Inside a method	✅ Yes + local vars	One-method helper
Anonymous Inner Class	Inline (no name)	✅ Yes + local vars	One-time implementation

1. Member Inner Class

A non-static class defined inside another class. It has access to ALL members of the outer class, including private:

Example

Output

LinkedList [4]: 5 -> 10 -> 20 -> 30 -> null
Iterating: 5 10 20 30

Creating a Member Inner Class Object

java example

// From outside the outer class:
LinkedList list = new LinkedList();
LinkedList.Iterator iter = list.iterator();      // Via factory method (preferred)
LinkedList.Iterator iter2 = list.new Iterator(); // Direct instantiation (less common)

2. Static Nested Class

A nested class with static modifier. It does NOT have access to the outer class's instance members:

Example

Output

Connected to: jdbc:mysql://localhost:3306/myapp [pool=10, timeout=5000ms]
Executing on jdbc:mysql://localhost:3306/myapp: SELECT * FROM users

3. Local Inner Class

Defined inside a method — limited scope, can access outer class members and effectively final local variables:

java example

public class ReportGenerator {
    private String companyName = "TechCorp";

    public void generateReport(String[] data, String reportType) {
        // Local inner class — exists only within this method
        class ReportFormatter {
            private String header;

            ReportFormatter(String header) {
                this.header = header;
            }

            void printReport() {
                System.out.println("=== " + header + " ===");
                System.out.println("Company: " + companyName);  // Accesses outer field
                System.out.println("Type: " + reportType);  // Accesses method parameter
                for (String item : data) {
                    System.out.println("  • " + item);
                }
                System.out.println("==================");
            }
        }

        ReportFormatter formatter = new ReportFormatter("Q4 Report");
        formatter.printReport();
    }
}

public class Main {
    public static void main(String[] args) {
        ReportGenerator gen = new ReportGenerator();
        gen.generateReport(
            new String[]{"Revenue: $1.2M", "Growth: 15%", "New Clients: 23"},
            "Quarterly Summary"
        );
    }
}

Output

=== Q4 Report ===
Company: TechCorp
Type: Quarterly Summary
  • Revenue: $1.2M
  • Growth: 15%
  • New Clients: 23
==================

Member Inner vs Static Nested — When to Use

java example

public class Outer {
    private int outerField = 42;

    // MEMBER inner class — needs outer instance
    class Inner {
        void accessOuter() {
            System.out.println("Outer field: " + outerField);  // ✅ Can access
            System.out.println("Outer this: " + Outer.this);   // ✅ Has reference
        }
    }

    // STATIC nested class — independent
    static class StaticNested {
        void tryAccessOuter() {
            // System.out.println(outerField);  // ❌ Cannot access!
            // System.out.println(Outer.this);  // ❌ No outer reference!
            System.out.println("I'm independent of any Outer instance");
        }
    }
}

Use Member Inner Class When:

The inner class needs access to the outer class's instance state
The inner class logically belongs to a specific instance
Example: Iterator for a collection

Use Static Nested Class When:

The inner class is logically related but doesn't need outer state
You want it to be instantiated independently
Example: Builder, Configuration, Node (in some cases)

Real-World Pattern: Builder with Static Nested Class

Example

Output

POST https://api.example.com/users [headers=2, timeout=5000ms]
Body: {"name": "Alice", "age": 30}

Common Mistakes

Trying to instantiate member inner class without outer:

``java // Inner inner = new Inner(); // ❌ Needs an outer instance Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); // ✅ ``

Memory leak with inner classes:

``java // Member inner class holds a reference to outer class // If inner lives longer than outer, outer can't be garbage collected! ``

Modifying local variables in local inner class:

``java int count = 0; class Local { void increment() { count++; // ❌ Must be effectively final! } } ``

Using member inner class when static would work:

``java // If the inner class doesn't use outer's instance fields, // make it static to avoid carrying an unnecessary reference. ``

Best Practices

Use static nested for Builder pattern and configuration classes
Use member inner classes for iterators and event handlers
Make inner classes private unless external access is needed
Prefer static nested over member inner to avoid hidden references
Keep inner classes small — if it grows large, extract to top-level
Watch for memory leaks with non-static inner classes in Android/long-lived contexts

Interview Questions

Q2: Can an inner class access private members of the outer class? Yes. Member inner classes can access ALL members (including private) of the enclosing class.

Q3: Can we have a static method in a member inner class? No (prior to Java 16). Only static nested classes can have static members. Java 16+ relaxes this rule.

Q4: Why does Java allow inner classes? For better encapsulation and logical grouping. Helper classes that only make sense in the context of another class can be nested inside it.

Q6: How do you access the outer class's this from an inner class? Use OuterClassName.this to get the outer class instance reference.

Exam Focus

Revise definitions, diagrams, examples, and short-answer points for Inner Class in Java.

Interview Use

Prepare one clear explanation, one practical example, and one common mistake for this Java Master Course topic.

Search Terms

java-master-course, java master course, java, master, course, oops, inner, class

Continue learning this concept

PreviousInheritance in Java NextInterface in Java