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();
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.
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();
}
}
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()
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;
}
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<c> = 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<c> = o.getClass().getEnclosingClass(); } The anonymous class defined by o is enclosed by MyClass.
String className = getClass().getName().substring(0, getClass().getName().indexOf("$"))
– josh.trow$1
then, because the name of the class is$1
. If you expect something else, usethis
in the right class instead of the wrong one. – ceving