Java - obtém o nome da classe atual?

Tudo o que estou tentando fazer é obter o nome da classe atual e o java acrescenta um inútil e inútil $ 1 ao final do nome da minha classe. Como posso me livrar dele e retornar apenas o nome da classe real?

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

O "$ 1" não é "inútil sem sentido". Se sua turma for anônima, um número será anexado.

Se você não quiser a classe em si, mas a classe declarante, poderá usar getEnclosingClass(). Por exemplo:

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

Você pode mover isso em algum método de utilitário estático.

Mas observe que esse não é o nome da classe atual. A classe anônima é diferente da classe envolvente. O caso é semelhante para classes internas.

Experimentar,

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

Isso funcionará desde que você não o use em um método estático.

Tente usar este this.getClass().getCanonicalName()ou this.getClass().getSimpleName(). Se for uma classe anônima, usethis.getClass().getSuperclass().getName()

Você pode usar this.getClass().getSimpleName(), assim:

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

A combinação de ambas as respostas. Também imprime um nome de método:

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

essa resposta está atrasada, mas acho que há outra maneira de fazer isso no contexto da classe de manipulador anônimo.

Digamos:

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

alcançará o mesmo resultado. Além disso, é realmente bastante conveniente, pois todas as classes são definidas em tempo de compilação, portanto, nenhuma dinamicidade é danificada.

acima disso, se a classe é realmente aninhada, ou seja, Ana verdade é delimitada por B, a classe B pode ser facilmente conhecida como:

B.this.getClass().getName()

No seu exemplo, thisprovavelmente se refere a uma instância de classe anônima. Java atribui um nome a essas classes anexando $numbera ao nome da classe envolvente.

Estou assumindo que isso está acontecendo para uma classe anônima. Quando você cria uma classe anônima, na verdade você cria uma classe que estende a classe cujo nome você recebeu.

A maneira "mais limpa" de obter o nome desejado é:

Se sua classe é uma classe interna anônima, getSuperClass()você deve fornecer a classe da qual ela foi criada. Se você o criou a partir de uma interface, é uma espécie de SOL, porque o melhor que você pode fazer égetInterfaces() que pode lhe dar mais de uma interface.

A maneira "hacky" é apenas pegar o nome getClassName()e usar um regex para soltar o $1.

Aqui está uma variante do Android, mas o mesmo princípio também pode ser usado em Java comum.

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

Descobri que isso funciona para o meu código, no entanto, meu código está obtendo a classe de uma matriz dentro de um loop for.

String className="";

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

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

APIs de reflexão

Existem várias APIs de reflexão que retornam classes, mas elas só podem ser acessadas se uma classe já tiver sido obtida direta ou indiretamente.

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

Retorna todas as classes públicas, interfaces e enumerações que são membros da classe, incluindo membros herdados.

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

Character contém duas classes de membros Character.Subset e
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

tem uma classe anexa.

        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.