Java - get the current class name?

All I am trying to do is to get the current class name, and java appends a useless non-sense $1 to the end of my class name. How can I get rid of it and only return the actual class name?

String className = this.getClass().getName();

Try,

String className = this.getClass().getSimpleName();

This will work as long as you don't use it in a static method.

The "$1" is not "useless non-sense". If your class is anonymous, a number is appended.

If you don't want the class itself, but its declaring class, then you can use getEnclosingClass(). For example:

Class<?> enclosingClass = getClass().getEnclosingClass();
if (enclosingClass != null) {
  System.out.println(enclosingClass.getName());
} else {
  System.out.println(getClass().getName());
}

You can move that in some static utility method.

But note that this is not the current class name. The anonymous class is different class than its enclosing class. The case is similar for inner classes.

Try using this this.getClass().getCanonicalName() or this.getClass().getSimpleName(). If it's an anonymous class, use this.getClass().getSuperclass().getName()

You can use this.getClass().getSimpleName(), like so:

import java.lang.reflect.Field;

public class Test {

    int x;
    int y;  

    public String getClassName() {

        String className = this.getClass().getSimpleName(); 
        System.out.println("Name:" + className);
        return className;
    }

    public Field[] getAttributes() {

        Field[] attributes = this.getClass().getDeclaredFields();   
        for(int i = 0; i < attributes.length; i++) {
            System.out.println("Declared Fields" + attributes[i]);    
        }

        return attributes;
    }

    public static void main(String args[]) {

        Test t = new Test();
        t.getClassName();
        t.getAttributes();
    }
}

The combination of both answers. Also prints a method name:

Class thisClass = new Object(){}.getClass();
String className = thisClass.getEnclosingClass().getSimpleName();
String methodName = thisClass.getEnclosingMethod().getName();
Log.d("app", className + ":" + methodName);

this answer is late, but i think there is another way to do this in the context of anonymous handler class.

let's say:

class A {
    void foo() {
        obj.addHandler(new Handler() {
            void bar() {
                String className=A.this.getClass().getName();
                // ...
            }
        });
    }
}

it will achieve the same result. additionally, it's actually quite convenience since every class is defined at compile time, so no dynamicity is damaged.

above that, if the class is really nested, i.e. A actually is enclosed by B, the class of B can be easily known as:

B.this.getClass().getName()

Here is a Android variant, but same principle can be used in plain Java too.

private static final String TAG = YourClass.class.getSimpleName();
private static final String TAG = YourClass.class.getName();

In your example, this probably refers to an anonymous class instance. Java gives a name to those classes by appending a $number to the name of the enclosing class.

I'm assuming this is happening for an anonymous class. When you create an anonymous class you actually create a class that extends the class whose name you got.

The "cleaner" way to get the name you want is:

If your class is an anonymous inner class, getSuperClass() should give you the class that it was created from. If you created it from an interface than you're sort of SOL because the best you can do is getInterfaces() which might give you more than one interface.

The "hacky" way is to just get the name with getClassName() and use a regex to drop the $1.

In my case, I use this Java class:

private String getCurrentProcessName() {
    String processName = "";
    int pid = android.os.Process.myPid();
    
    ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
    for (ActivityManager.RunningAppProcessInfo processInfo : manager.getRunningAppProcesses()) {
        if (processInfo.pid == pid) {
            processName = processInfo.processName;
            break;
        }
    }
    
    return processName;
}

I've found this to work for my code,, however my code is getting the class out of an array within a for loop.

String className="";

className = list[i].getClass().getCanonicalName();

System.out.print(className); //Use this to test it works

Reflection APIs

> There are several Reflection APIs which return classes but these may > only be accessed if a Class has already been obtained either directly > or indirectly. >
>
> > Class.getSuperclass() > Returns the super class for the given class. > > Class c = javax.swing.JButton.class.getSuperclass(); > The super class of javax.swing.JButton is javax.swing.AbstractButton. > > Class.getClasses() > > Returns all the public classes, interfaces, and enums that are members > of the class including inherited members. > > Class[] c = Character.class.getClasses(); > > Character contains two member classes Character.Subset and
> Character.UnicodeBlock. > > Class.getDeclaredClasses() > Returns all of the classes interfaces, and enums that are explicitly declared in this class. > > Class[] c = Character.class.getDeclaredClasses(); > Character contains two public member classes Character.Subset and Character.UnicodeBlock and one private class > Character.CharacterCache. > > Class.getDeclaringClass() > java.lang.reflect.Field.getDeclaringClass() > java.lang.reflect.Method.getDeclaringClass() > java.lang.reflect.Constructor.getDeclaringClass() > Returns the Class in which these members were declared. Anonymous Class Declarations will not have a declaring class but will > have an enclosing class. >
> import java.lang.reflect.Field; >
> Field f = System.class.getField("out"); > Class c = f.getDeclaringClass(); > The field out is declared in System. > public class MyClass { > static Object o = new Object() { > public void m() {} > }; > static Class = o.getClass().getEnclosingClass(); > } >
> The declaring class of the anonymous class defined by o is null. > > Class.getEnclosingClass() > Returns the immediately enclosing class of the class. >
> Class c = Thread.State.class().getEnclosingClass(); > The enclosing class of the enum Thread.State is Thread. > > public class MyClass { > static Object o = new Object() { > public void m() {} > }; > static Class = o.getClass().getEnclosingClass(); > } > The anonymous class defined by o is enclosed by MyClass.