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 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 object 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 {
}
} |
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 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 object 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));
}
} |
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 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);
}
} |
Is gfg an inner class object? : true