Inner Class in JAVA

(You can learn about Static Nested Class here )

2. Non-Static Nested class

Declaration: class InnerClassName{}

Characteristics:

1. Exists within an instance of the outer class.
2. Has access to both Static and Non-Static members of the Outer class.
3. It can be instantiated using an instance of the outer class OuterInstance.new InnerClass();

example:

public class OuterClass {
    private int outerField;

    public class InnerClass {
        public void innerMethod() {
            outerField = 10; // Accessing the outer class's field
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.innerMethod();
    }
}

In this example, InnerClass is an inner class of OuterClass. To instantiate InnerClass, you need an instance of OuterClass, as shown in the main method. Inner classes can access the members of the outer class, even private ones, as demonstrated by innerMethod accessing outerField.

Inner classes can also be local to a block of code or an expression, known as local inner classes, or they can be anonymous inner classes, which are used for one-time use cases like event handling.

Key Advantage:

Encapsulation: Inner class related strong encapsulation by grouping related functionality within the outer class, hiding implemeted details from the outside world.

Get BansodThomas’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

Access to Outer Class members: Static and Non-Static members.

example:

public class OuterClass {
    private int outerField;

    public OuterClass(int outerField) {
        this.outerField = outerField;
    }

    // Non-static nested class
    public class InnerClass {
        private int innerField;

        public InnerClass(int innerField) {
            this.innerField = innerField;
        }

        public void display() {
            System.out.println("Outer field: " + outerField);
            System.out.println("Inner field: " + innerField);
        }
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass(10);
        OuterClass.InnerClass inner = outer.new InnerClass(20);
        inner.display();
    }
}

Common Use Cases:

Helper Class: Inner Class often serve as helper class to support the outer class functionality.

example:

public class OuterClass {
    
    private int data;

    public OuterClass(int data) {
        this.data = data;
    }

    // Inner class serving as a helper
    private class Helper {
        public void displayData() {
            System.out.println("Data from outer class: " + data);
        }
    }

    public void useHelper() {
        Helper helper = new Helper();
        helper.displayData();
    }
    
    public static void main(String[] args) {
        OuterClass outer = new OuterClass(42);
        outer.useHelper();
    }
}

Implementing Interfaces: They can be used to Implement Interface specify for the outer class, with out exposing them to the outside world.

example:

interface Interface {
    void method();
}

public class OuterClass {

    private class InnerClass implements Interface {
        public void method() {
            System.out.println("Implemented method in InnerClass");
        }
    }

    public Interface getInnerClass() {
        return new InnerClass();
    }

    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        Interface inner = outer.getInnerClass();
        inner.method();
    }
}

Reach Me at:

LinkedIn , Email