Nested Static Class

A school program needs reliable data and clear rules. A static nested class is named inside another class but does not require an instance of the enclosing class. Use it for a related helper without unnecessary object coupling.

In Java, classes can be defined inside other classes — these are called nested classes. When a nested class is marked as static, it becomes a nested static class. This concept might seem a little strange at first, but it's extremely useful when a class logically belongs to another class, yet does not require access to the outer class's instance variables or methods.

• To group classes that belong together logically.
• To improve encapsulation and code organization.
• To access the nested class without creating an instance of the outer class.

class OuterClass {
    static class NestedStaticClass {
        void display() {
            System.out.println("Inside static nested class.");
        }
    }
}

Because the nested class is static, you don’t need an instance of the outer class to create its object. Here's how you do it:

public class Test {
    public static void main(String[] args) {
        OuterClass.NestedStaticClass obj = new OuterClass.NestedStaticClass();
        obj.display();
    }
}

Inside static nested class.

Java · example discussed here

public class Test {
    public static void main(String[] args) {
        OuterClass.NestedStaticClass obj = new OuterClass.NestedStaticClass();
        obj.display();
    }
}

We define NestedStaticClass inside OuterClass and mark it as static. In main(), we directly access the static nested class using the syntax OuterClass.NestedStaticClass without needing an object of OuterClass.

A static nested class can access all static members (variables and methods) of its outer class:

class Outer {
    static int outerValue = 42;

    static class StaticInner {
        void show() {
            System.out.println("Outer static value: " + outerValue);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        Outer.StaticInner obj = new Outer.StaticInner();
        obj.show();
    }
}

Outer static value: 42

Static nested classes cannot access non-static members of the outer class directly. If you try to do so, you’ll get a compilation error. Here’s an example:

class Outer {
    int outerInstanceVar = 5;

    static class StaticInner {
        void show() {
            // System.out.println(outerInstanceVar); // ❌ Error: Cannot access non-static variable
        }
    }
}

Just like any other class, you can add constructors to static nested classes:

class Book {
    static class Publisher {
        String name;

        Publisher(String name) {
            this.name = name;
        }

        void print() {
            System.out.println("Published by: " + name);
        }
    }
}

public class DemoPublisher {
    public static void main(String[] args) {
        Book.Publisher p = new Book.Publisher("TutorialKart Publishing");
        p.print();
    }
}

Published by: TutorialKart Publishing

Imagine you’re designing a Car class. You might define a static nested class called EngineSpecs inside Car because it logically belongs to Car but doesn't need direct access to car's instance-level properties (like color or mileage).

• When the nested class is only relevant to its outer class.
• When the nested class doesn't need access to the outer class’s instance variables or methods.
• To enhance code readability and structure.

The static nested class in Java is a neat tool to structure your code better, especially when dealing with logically grouped elements. While it can’t access instance variables of the outer class, its ability to operate independently makes it a clean and encapsulated design choice.

Static does not forbid instance fields in the nested class itself. It removes the implicit enclosing object requirement.

Before running this Java program, write down each line you expect to see. Identify the value, branch, object or exception responsible for each line. Then explain whether the following assumption is valid: Static does not forbid instance fields in the nested class itself.

Java 17 · Main.java · complete practice program

public class Main  {
  static class SchoolRoom  {
    static class Label  {
      String text = "Class 10A";
    }
  }
  public static void main(String[] args)  {
    System.out.println(new SchoolRoom.Label().text);
  }
}

Java 17 · Main.java · source repeated for this answer

public class Main  {
  static class SchoolRoom  {
    static class Label  {
      String text = "Class 10A";
    }
  }
  public static void main(String[] args)  {
    System.out.println(new SchoolRoom.Label().text);
  }
}

Expected output

Class 10A

A static nested class is named inside another class but does not require an instance of the enclosing class. Use it for a related helper without unnecessary object coupling.

Static does not forbid instance fields in the nested class itself. It removes the implicit enclosing object requirement.

Run with javac Main.java, then java Main. The declaration inside Main keeps the helper type available to this standalone example.

A static nested class is named inside another class but does not require an instance of the enclosing class. Use it for a related helper without unnecessary object coupling. Static does not forbid instance fields in the nested class itself. It removes the implicit enclosing object requirement.

Related explanations: Java Variables, Java If Statement - Syntax and Examples, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide and Java 17 language specification.