Local Inner Classes are classes declared inside a block. These classes are only visible inside the block. So, You need to instantiate the class within the block. Sometimes, this block can be for loop or if-else clause. These classes can access the fields of a class enclosing it. The local inner class must be instantiated in the block they are defined in.
We will discuss using the below approaches how to check if a given class is a Local Inner Class.
Approach 1:
- To check whether the class is a local inner class, java.lang.Class provides a method called isLocalClass().
- This method returns true if the given class is a local class and false otherwise. Note that “isLocalClass()” is defined in java.lang.Class class. So, you need to first call the “getClass()” method of the object.
- This method returns the Class instance representing the class of the object. See the following code —
Java
// Java program to check if a class is inner // local class using isLocalClass() method import java.io.*; class GFG { public static void main(String[] args) { class LocalInnerClass { // This is a local inner class } // Creating a LocalInnerClass object LocalInnerClass inner = new LocalInnerClass(); // Getting the Class instance associated with // the class of inner(i.e. LocalInnerClass) // which is returned by getClass() method of inner Class localClass = inner.getClass(); // isLocalClass() method of localClass returns true // if and only if localClass is a Local Class System.out.println( "Is inner a local class object? :" + localClass.isLocalClass()); } } |
Is inner a local class object? :true
Approach 2:
- This approach is about checking the canonical name of the class and then deciding whether it is a local class or not.
- The getCanonicalName() method defined in java.lang.
- Class class, returns the canonical name of the class in as a string.
- For example, if the name of a class represented by the java.lang.Class object, is “GFG”, then the “getCanonicalName()” method returns “GFG”.
GFG gfg = new GFG(); System.out.println(gfg.getClass().getCanonicalName());
If we run the above code in a program, then the output received will be:
Output :
GFG
Note: A.) If there is a package name, then the output will be “package-name.GFG”.
- But this is not the case for local, anonymous classes.
- If the class is a member class, say, “GFG” is a member class of “GeeksForGeeks”, then “getCanonicalName()” will return “GeeksForGeeks.GFG”(in the form “(Name_of_Enclosing_Class).(Name_of_this_Class)”).
Java
// Java program to check what the method returns // when class is an annymous class import java.io.*; class GeeksForGeeks { public static void main(String[] args) { // Creating a GeeksForGeeks object // to create a GFG object GeeksForGeeks geeks = new GeeksForGeeks(); // Creating a GFG object GFG gfg = geeks. new GFG(); // getClass() returns a java.lang.Class // instance representing the GFG class System.out.println( gfg.getClass().getCanonicalName()); } class GFG { // This is a member class of GeeksForGeeks } } |
GeeksForGeeks.GFG
B.) If the class is an anonymous class inside a class (say, “GFG”) then the “getCanonicalName()” method returns null because it does not have a canonical name.
Java
// java program to check what the method returns // when class is an annymous class import java.io.*; class GFG { public static void main(String[] args) { GFG gfg = new GFG() { // This is an Anonymous class // that extends the GFG class }; // Remember to put the semicolon here System.out.println( gfg.getClass().getCanonicalName()); } } |
null
C.) If the class is a local inner class, suppose, “GFG” is a local class inside “GeeksForGeeks”, then also “getCanonicalName()” will return null. Because, it does not have a canonical name
Java
// Java program to check if a class is a // local inner class import java.io.*; class GeeksForGeeks { public static void main(String[] args) { class GFG { // This is a local class } class Geeks { // This is an another local class } GFG gfg = new GFG(); Geeks geeks = new Geeks(); System.out.println( "Canonical Name of the class of gfg:" + gfg.getClass().getCanonicalName()); System.out.println( "Canonical Name of the class of geeks:" + geeks.getClass().getCanonicalName()); } } |
Canonical Name of the class of gfg:null Canonical Name of the class of geeks:null
Using this canonical name, you can achieve the given task. Check the following code:
Java
// Java program to check if the class // local inner class import java.io.*; class GeeksForGeeks { public static void main(String[] args) { class GFG { // This is a local class } GFG gfg = new GFG(); // Storing the class instance associated with gfg // i.e. Class instance representing GFG Class classInstance = gfg.getClass(); // Checking whether the classInstance has a // canonical name boolean hasCanonicalName = (classInstance.getCanonicalName() != null ); // If hasCanonicalName is false then it is sure that // either it is a local class or anonymous class or // an array whose component type does not have a // canonical name // Now check whether it is an anonymous Class boolean isAnonymousClass = classInstance.isAnonymousClass(); // Check if it is an array boolean isArray = classInstance.isArray(); // If all the three isArray,isAnonymousClass and // hasCanonicalName are false then the classInstance // is surely a local class boolean isLocalClass = (!hasCanonicalName && !isAnonymousClass && !isArray); System.out.println( "Is gfg a local class instance?: " + isLocalClass); } } |
Is gfg a local class instance?: 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.