Java Program to Check if a Given Class is an Inner Class

Last Updated : 15 Dec, 2020

Inner class is a member of another class which is basically a non-static nested class i.e. if a class is inside another class and is not static, then the class is called is referred to as an inner class.

Types of Inner Classes:

Approach 1:

First check if the given class is a nested class
Further it is checked whether the class is a non-static class.
- If both conditions are true, then the given class is an inner class.
Now in order to check if the given class is a nested class, java.lang.Class#getEnclosingClass() method is used that returns a Class instance representing the immediately enclosing class of the object.
- If the class is a top-level class then the method will return null.
- This means that if the class is not nested then the method returns null.
Further it is checked whether the given class is static using the java.lang.reflect.Modifier.isStatic() method.

Program to check for nested inner classes

Java

// Java Program to Check if a Given Class is  an Inner Class 
  
// Importing package where Modifier is defined 
import java.lang.reflect.Modifier; 
  
class GFG { 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
  
        // Creating as GFG class object 
        GFG gfg = new GFG(); 
  
        // Creating a InnerClass object 
        InnerClass innerClass = gfg.new InnerClass(); 
  
        // Creating a Static Nested Class object 
        StaticNestedClass statNested 
            = new StaticNestedClass(); 
  
        // getClass() method of an object returns a 
        // java.lang.Class instance representing the class 
        // of the object 
        Class classInstance1 = innerClass.getClass(); 
        Class classInstance2 = statNested.getClass(); 
  
        // Checking if the given classes are nested 
  
        // getEnclosinglClass() of Class instance returns a 
        // class onject representing the immediate enclosing 
        // class of the instance 
  
        boolean isNested1 
            = classInstance1.getEnclosingClass() != null; 
        // classInstance1() method returns a Class object 
  
        // If the specified class is a top-level class, then 
        // it would returns null 
  
        boolean isNested2 
            = classInstance2.getEnclosingClass() != null; 
  
        //  Check if the given classes are static 
  
        // getModifiers() method of a class returns the 
        // modifiers of the class encoded as an integer 
  
        // Modifiers.isStatic returns true if the class 
        // has a static modifier elsereturns false 
        boolean isStatic1 = Modifier.isStatic( 
            classInstance1.getModifiers()); 
        boolean isStatic2 = Modifier.isStatic( 
            classInstance2.getModifiers()); 
  
        // If the given classes are nested and non-static, 
        // then given classes are surely inner classes 
  
        // Display message 
        System.out.println( 
            "Is innerClass an inner class object? : "
            + (isNested1 && !isStatic1)); 
  
        // Display message 
        System.out.println( 
            "Is statNested an inner class object? : "
            + (isNested2 && !isStatic2)); 
    } 
  
    // Inner Class 
    class InnerClass { 
    } 
  
    // Static nested class 
    static class StaticNestedClass { 
    } 
}

Output

Is innerClass an inner class object? : true
Is statNested an inner class object? : false

Similarly, for local and anonymous inner classes, the above logic returns true.

Program to check for local and anonymous inner classes

Java

// Java Program to Check if a  
// Given Class is an Inner Class 
  
// Importing package where Modifier is defined 
import java.lang.reflect.Modifier; 
  
class GFG { 
  
    public static void main(String[] args) 
    { 
        // Creating an anonymous class object 
        GFG gfg = new GFG() { 
            // This is an anonymous class that extends class 
            // GFG 
        }; 
  
        class LocalInnerClass { 
            // This is a local inner class 
        } 
  
        // Creating a LocalInnerClass object 
        LocalInnerClass innerClass = new LocalInnerClass(); 
  
        // getClass() method of an object returns a 
        // instance representing the class of the object 
        Class classInstance1 = gfg.getClass(); 
        Class classInstance2 = innerClass.getClass(); 
  
        // Checking if the given classes are nested 
  
        // getEnclosinglClass() of Class instance returns a 
        // class onject representing the immediate enclosing 
        // class of the instance 
        boolean isNested1 
            = classInstance1.getEnclosingClass() != null; 
  
        // classInstance1() method returns a Class object 
  
        // If the specified class is a top-level class, then 
        // it would returns null 
        boolean isNested2 
            = classInstance2.getEnclosingClass() != null; 
  
        // Checking if the given classes are nested 
  
        // getModifiers() method of a class returns the 
        // modifiers of the class encoded as an integer 
        // Modifiers 
        boolean isStatic1 = Modifier.isStatic( 
            classInstance1.getModifiers()); 
  
        // isStatic() returns true if the class has a static 
        // modifier else returns false 
        boolean isStatic2 = Modifier.isStatic( 
            classInstance2.getModifiers()); 
  
        // Now by this end, classes are nested & non-static 
        // Then given classes are surely inner classes 
  
        // Print the results 
        System.out.println( 
            "Is gfg an inner class object? : "
            + (isNested1 && !isStatic1)); 
        System.out.println( 
            "Is innerClass an inner class object? : "
            + (isNested2 && !isStatic2)); 
    } 
}

Output

Is gfg an inner class object? : true
Is innerClass an inner class object? : true

Approach 2:

Directly checking whether the class is local, or a member, or an anonymous class using java.lang.Class#isLocalClass(), java.lang.Class#isMemberClass(), java.lang.Class#isAnonymousClass() methods.
If the given class is none of them, then the class is not an inner class.
If the class is one of them, then check if the class is static or not using the java.lang.reflect.Modifier.isStatic() method.
Print the result when all the conditions are properly satisfied

Note: However, if you just want to check if the class is a nested class, then you can simply use the java.lang.Class#isLocalClass(), java.lang.Class#isMemberClass(), java.lang.Class#isAnonymousClass() methods. If any of them returns true for a given class, then it is certain that the class is a nested class.

Example

Java

// Java Program to Check if a Given 
// Class is an Inner Class 
  
// Importing package where Modifier is defined 
import java.lang.reflect.Modifier; 
  
class GFG { 
  
    // Main driver method 
    public static void main(String[] args) 
    { 
  
        // Creating a local inner class object 
        GFG gfg = new GFG() { 
  
        }; 
  
        // getClass() method of an object returns a 
        // java.lang.CLass 
        // instance representing the class of the object 
        Class classInstance = gfg.getClass(); 
  
        // Checking whether Class is - 
        // local, member, an anonymous inner class 
        // and not static 
        boolean isInnerClass 
            = (classInstance.isMemberClass() 
               || classInstance.isLocalClass() 
               || classInstance.isAnonymousClass()) 
              && !Modifier.isStatic( 
                     classInstance.getModifiers()); 
  
        // Printing the results 
        System.out.println( 
            "Is gfg an inner class object? : "
            + isInnerClass); 
    } 
}

Output

Is gfg an inner class object? : true

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.

My Personal Notes

Related Articles

Java

Java

Java