Static Class in Java

Example of Static and Non-Static Nested Classes

Let's look at real code examples to understand how static and non-static nested classes work in practice. We'll create an outer class called University with both types of nested classes.

1. Static Nested Class Example

public class University {
    // Static variable of outer class
    static String universityName = "Tech University";
    
    // Static nested class
    static class Department {
        void display() {
            // Can only access static members of outer class
            System.out.println("Department of " + universityName);
        }
    }


    public static void main(String[] args) {
        // Creating object of static nested class
        University.Department dept = new University.Department();
        dept.display();  // Output: Department of Tech University
    }
}

You can also try this code with Online Java Compiler

Run Code

Key Points:

• We created the Department static nested class without needing a University object
   
• The display() method can only access the static universityName variable
   
• Object creation is simple: University.Department dept = new University.Department();

2. Non-Static Nested Class (Inner Class) Example

public class University {
    // Instance variable of outer class
    String universityName = "Tech University";
    
    // Non-static inner class
    class Student {
        void display() {
            // Can access both static and non-static members
            System.out.println("Student of " + universityName);
        }
    }


    public static void main(String[] args) {
        // First create outer class object
        University uni = new University();
        
        // Then create inner class object
        University.Student student = uni.new Student();
        student.display();  // Output: Student of Tech University
    }
}

You can also try this code with Online Java Compiler

Run Code

Key Points:

• We needed a University object (uni) before creating the Student inner class object
   
• The inner class can access the instance variable universityName
   
• Object creation requires two steps: first outer object, then inner object

3. Combined Example Showing Both Types

public class Computer {
    // Outer class variable
    String brand = "TechComp";
    static String type = "Laptop";
    
    // Static nested class
    static class Processor {
        void show() {
            System.out.println("Processor for " + type);  // Can access static 'type'
            // System.out.println(brand);  // Error - can't access non-static
        }
    }
    
    // Non-static inner class
    class RAM {
        void display() {
            System.out.println("RAM for " + brand);  // Can access non-static
            System.out.println("Device type: " + type);  // Can also access static
        }
    }


    public static void main(String[] args) {
        // Static nested class usage
        Computer.Processor cpu = new Computer.Processor();
        cpu.show();
        
        // Non-static inner class usage
        Computer comp = new Computer();
        Computer.RAM memory = comp.new RAM();
        memory.display();
    }
}

You can also try this code with Online Java Compiler

Run Code

Output:

Processor for Laptop
RAM for TechComp
Device type: Laptop

Frequently Asked Questions

Can a nested class (static one) access non-static members of the outer?

No, a nested class that is not dynamic can only access the static members (variables & methods) of the outside class. It will result in a compilation error when it attempts to access non-static members.

Why should I use a static nested class as opposed to a normal inner class?

Choose a static nested class in the case that the nested class has no use cases of accessing instance variables of the outer class. This makes the code use less memory to store a reference to the outer class.

May non-static methods exist in a static nested class?

Yes, a non-static method may be included in a static nested class. But still it has no access to non-static members of the outer class.

Conclusion

We have come to understand in this article about static classes in Java. We observed the difference between them in creation of objects and the use of memory and in accessing members of outer classes over the non-static nested classes. We also had a practical example to see how static and non-static nested classes work in practice.We find useful a static nested class when we want to have a helper class but have no need to refer to instances of the outer class, and a non-static inner class when we want full access to instance variables of the outer class. The selection of the proper type assists in the creation of a cleaner and more productive code.