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

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());
    }
}

Output

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 anonymous 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
    }
}

Output

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 anonymous 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());
    }
}

Output

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());
    }
}

Output

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);
    }
}

Output

Is gfg a local class instance?: true