Difference Between Static and Non Static Nested Class in Java

17 Feb, 2022
Nested classes are divided into two categories namely static and non-static. Nested classes that are declared static are called static nested classes. Non-static nested classes are called inner classes.
A class can either be static or non-static in java. So there is a lot of difference between making a class static or non-static. There are two kinds of classes in Java, one is called a top-level class and the other is called a nested class. As the name suggested top-level class is a class that is declared in ‘.java’ file. 
On the other hand, a nested class is declared inside another class. The class which enclosed nested class is known as Outer class. In the Java programming language, you can not make a top-level class static. You can only make nested classes either static or non-static. If you make a nested class non-static then it also referred to as Inner class. 
User-cases:
Static nested class
Non-static nested class
Example 1: Static nested class
Java
// Java Program to illustrate// static nested class // Importing input output classesimport java.io.*;// Importing all classes from// java.util packageimport java.util.*; // Class 1// Helper class1class ClassA {     // Static variable    static int x = 10;     int y = 20;     // Static variable with private    // access modifier in ClassA    private static int z = 30;     // Class 2 - Nested static class    // Helper Class 2    static class ClassB {         // Method of nested static class        void get()        {            // Execution statements whenever            // function is called             // Print and display commands            System.out.println("x: " + x);            System.out.println("z: " + z);        }    }} // Class 3// Main Classclass GFG {     // Main driver method    public static void main(String[] args)    {        // Creating an object of static nested class        // defined outside Main class        ClassA.ClassB ob1 = new ClassA.ClassB();         // Calling the method od static nested class        // in main() method        ob1.get();    }}
  
x: 10
z: 30
 
Example 2: Non-static nested class
 
Java
// Importing all input output classesimport java.io.*; // Class 1// Helper Class 1class ClassA {     // Static member variable of ClassA    static int x = 10;     int y = 20;    public int z = 30;     // Class 2 - Helper Class 2    // Non-static nested class    class ClassB {         // Method of Non-static nested class        void get()        {            // Execution command of get() method             // Print and display commands            System.out.println("x: " + x);            System.out.println("y: " + y);            System.out.println("z: " + z);        }    }} // Class 3// Main Classclass GFG {     // Main driver method    public static void main(String[] args)    {        // Creating object of Class 1 in main() method        ClassA ob1 = new ClassA();         // Creating object of non-static nested class in        // main()        ClassA.ClassB ob2 = ob1.new ClassB();         // Calling non-static nested class method        // in main() method        ob2.get();    }}
  
x: 10
y: 20
z: 30
 
Now the difference between Static and Non-Static Nested Class in Java:
 
The static inner class can access the static members of the outer class directly. But, to access the instance members of the outer class you need to instantiate the outer class.
Nested static class doesn’t need a reference of Outer class but a nonstatic nested class or Inner class requires Outer class reference.
A non-static nested class has full access to the members of the class within which it is nested. A static nested class does not have a reference to a nesting instance, so a static nested class cannot invoke non-static methods or access non-static fields of an instance of the class within which it is nested.
Another difference between static and non-static nested class is that you can not access non-static members e.g. method and field into nested static class directly. If you do you will get errors like “nonstatic member can not be used in the static context”. While the Inner class can access both static and non-static members of the Outer class.
 
sweetyty
sumitgumber28
Picked
Technical Scripter 2020
Difference Between
Java
Technical Scripter
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.