Java: ottieni il nome della classe corrente?

Tutto quello che sto cercando di fare è ottenere il nome della classe corrente e java aggiunge un inutile non senso $ 1 alla fine del mio nome di classe. Come posso liberarmene e restituire solo il nome della classe attuale?

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

"$ 1" non è "inutile non-senso". Se la tua classe è anonima, viene aggiunto un numero.

Se non vuoi la classe stessa, ma la sua classe dichiarante, puoi usare getEnclosingClass(). Per esempio:

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

Puoi spostarlo in qualche metodo di utilità statica.

Ma nota che questo non è il nome della classe corrente. La classe anonima è diversa dalla classe che la racchiude. Il caso è simile per le classi interne.

Provare,

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

Funzionerà finché non lo usi in un metodo statico.

Prova a usare questo this.getClass().getCanonicalName()o this.getClass().getSimpleName(). Se si tratta di una classe anonima, utilizzarethis.getClass().getSuperclass().getName()

Puoi usare this.getClass().getSimpleName(), in questo modo:

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

La combinazione di entrambe le risposte. Stampa anche il nome di un metodo:

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

questa risposta è in ritardo, ma penso che ci sia un altro modo per farlo nel contesto di una classe di gestori anonimi.

diciamo:

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

otterrà lo stesso risultato. inoltre, in realtà è abbastanza comodo poiché ogni classe è definita al momento della compilazione, quindi nessuna dinamica è danneggiata.

sopra quello, se la classe è veramente nidificata, cioè Aè effettivamente racchiusa da B, la classe di B può essere facilmente conosciuta come:

B.this.getClass().getName()

Nel tuo esempio, thisprobabilmente si riferisce a un'istanza di classe anonima. Java dà un nome a quelle classi aggiungendo $numbera al nome della classe che la racchiude.

Suppongo che ciò accada per una classe anonima. Quando crei una classe anonima, crei effettivamente una classe che estende la classe di cui hai il nome.

Il modo "più pulito" per ottenere il nome desiderato è:

Se la tua classe è una classe interna anonima, getSuperClass()dovresti fornirti la classe da cui è stata creata. Se l'hai creato da un'interfaccia di quanto sei una specie di SOL perché il meglio che puoi fare è getInterfaces()che potrebbe darti più di un'interfaccia.

Il modo "hacky" è semplicemente ottenere il nome getClassName()e usare una regex per rilasciare il file $1.

Ecco una variante di Android, ma lo stesso principio può essere usato anche in Java.

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

Ho trovato che questo funziona per il mio codice, tuttavia il mio codice sta estraendo la classe da un array all'interno di un ciclo for.

String className="";

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

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

API di riflessione

Esistono diverse API Reflection che restituiscono classi, ma è possibile accedervi solo se una Classe è già stata ottenuta direttamente o indirettamente.

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

Restituisce tutte le classi, le interfacce e le enumerazioni pubbliche che sono membri della classe inclusi i membri ereditati.

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

Character contiene due classi membro 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

avere una classe chiusa.

        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.