Java-获取当前的类名？

我要做的就是获取当前的类名，并且java在类名的末尾附加了一个无用的废话$ 1。如何摆脱它，只返回实际的类名？

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

“ $ 1”不是“无用的废话”。如果您的班级是匿名的，则会附加一个数字。

如果您不想要类本身，而是想要其声明类，则可以使用getEnclosingClass()。例如：

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

您可以将其移动到某些静态实用程序方法中。

但是请注意，这不是当前的类名。匿名类与其封闭类是不同的类。内部类的情况与此类似。

尝试，

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

只要您不以静态方法使用它，它将起作用。

尝试使用此 this.getClass().getCanonicalName()或this.getClass().getSimpleName()。如果是匿名类，请使用this.getClass().getSuperclass().getName()

您可以这样使用this.getClass().getSimpleName()：

import java.lang.reflect.Field;

public class Test {

    int x;
    int y;  

    public void getClassName() {
        String className = this.getClass().getSimpleName(); 
        System.out.println("Name:" + className);
    }

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

    public static void main(String args[]) {

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

两种答案的结合。同时显示方法名称：

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

这个答案来晚了，但是我认为在匿名处理程序类的上下文中还有另一种方法可以做到这一点。

比方说：

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

它会达到相同的结果。此外，由于每个类都是在编译时定义的，因此实际上很方便，因此不会破坏动态性。

除此之外，如果该类确实是嵌套的，即A实际上被包围B，则B的类可以很容易地称为：

B.this.getClass().getName()

在您的示例中，this可能是指一个匿名类实例。Java通过将a附加$number到封闭类的名称中来为这些类命名。

我假设这是在匿名类中发生的。当您创建匿名类时，实际上是在创建一个类，该类扩展了您所用的名称。

获得所需名称的“更清洁”方法是：

如果您的课程是匿名内部课程，getSuperClass()则应为您提供创建该课程的课程。如果您是从某个界面创建它的，那么您就不是SOL，因为您能做的最好的事情就是getInterfaces()可能为您提供多个界面。

“ hacky”方式是仅getClassName()使用来获取名称，然后使用正则表达式删除$1。

这是一个Android变体，但是相同的原理也可以在纯Java中使用。

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

我发现这适用于我的代码，但是我的代码是将类从for循环内的数组中取出。

String className="";

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

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

反射API

有几种反射API返回类，但是只有在已经直接或间接获得类的情况下，才可以访问这些API。

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

返回属于该类成员的所有公共类，接口和枚举，包括继承的成员。

        Class<?>[] c = Character.class.getClasses();

字符包含两个成员类Character.Subset和
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

有一个封闭的类。

        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.