Inner Classes in Java

Introduction#

In Java, Inner Classes are classes that are defined within another class. They provide better encapsulation, logical grouping of related classes, and improved code organization. Understanding inner classes is crucial as they are often used in real-world scenarios like event handling, multithreading, and UI development.

In this blog, we will cover:

• What are inner classes?
• Why do we need inner classes?
• Types of inner classes with examples.
• When and where to use inner classes.

1. What are Inner Classes?#

An Inner Class is a class that is declared inside another class or interface. The inner class has access to all members of its enclosing class, even private members.

Syntax:#

class OuterClass {
    class InnerClass {
        // Inner class code
    }
}

2. Why Do We Need Inner Classes?#

Inner classes are useful in several scenarios:

• Encapsulation: Helps in logically grouping classes that are only used by the enclosing class.
• Code Readability: Reduces clutter by keeping closely related logic together.
• Event Handling: Commonly used in GUI applications and event-driven programming (e.g., in Swing or JavaFX).
• Accessing Private Members: Inner classes can access private members of the outer class, making them useful in scenarios requiring close interaction between classes.

3. Types of Inner Classes in Java#

Java provides four types of inner classes:

3.1. Member Inner Class#

A Member Inner Class is a non-static class that is defined inside another class. It can access all members (even private) of the outer class.

Example:#

class Outer {
    private String message = "Hello from Outer class!";

    class Inner {
        void showMessage() {
            System.out.println(message); // Accessing private member
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner(); // Creating instance of Inner class
        inner.showMessage();
    }
}

Output:#

Hello from Outer class!

3.2. Static Nested Class#

Unlike member inner classes, a Static Nested Class is declared with the static keyword and cannot access non-static members of the outer class directly.

Example:#

class Outer {
    static String staticMessage = "Hello from Static Outer Class!";

    static class StaticNested {
        void display() {
            System.out.println(staticMessage); // Accessing static member of Outer class
        }
    }

    public static void main(String[] args) {
        Outer.StaticNested nested = new Outer.StaticNested(); // No need for Outer instance
        nested.display();
    }
}

Output:#

Hello from Static Outer Class!

3.3. Local Inner Class#

A Local Inner Class is defined within a method and can only be used inside that method.

Example:#

class Outer {
    void outerMethod() {
        class LocalInner {
            void display() {
                System.out.println("Inside Local Inner Class");
            }
        }
        LocalInner local = new LocalInner();
        local.display();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.outerMethod();
    }
}

Output:#

Inside Local Inner Class

3.4. Anonymous Inner Class#

An Anonymous Inner Class is a class that does not have a name and is used when we need to override a method of a class or an interface inline.

Example:#

abstract class Animal {
    abstract void sound();
}

public class Main {
    public static void main(String[] args) {
        Animal cat = new Animal() { // Anonymous Inner Class
            void sound() {
                System.out.println("Meow Meow");
            }
        };
        cat.sound();
    }
}

Output:#

Meow Meow

4. When and Where to Use Inner Classes?#

Now that we have explored different types of inner classes, let’s see where they are useful:

Conclusion#

In this blog, we learned:

• What inner classes are and why they are useful.
• The four types of inner classes: Member Inner Class, Static Nested Class, Local Inner Class, and Anonymous Inner Class.
• Real-world use cases for inner classes.