Java – krijg je de huidige klasnaam?

Het enige wat ik probeer te doen is de huidige klasnaam te krijgen, en java voegt een nutteloze onzin $1toe aan het einde van mijn klasnaam. Hoe kan ik er vanaf komen en alleen de echte klasnaam teruggeven?

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

Antwoord 1, autoriteit 100%

De “$1” is geen “nutteloze onzin”. Als je klas anoniem is, wordt er een nummer toegevoegd.

Als je de klasse zelf niet wilt, maar de declarerende klasse, dan kun je getEnclosingClass()gebruiken. Bijvoorbeeld:

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

Je kunt dat in een statische hulpprogramma-methode verplaatsen.

Maar houd er rekening mee dat dit niet de huidige klassenaam is. De anonieme klasse is een andere klasse dan de omsluitende klasse. Het geval is vergelijkbaar voor innerlijke klassen.

Antwoord 2, autoriteit 99%

Probeer,

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

Dit werkt zolang je het niet in een statische methode gebruikt.

Antwoord 3, autoriteit 12%

Probeer dit te gebruiken
this.getClass().getCanonicalName()of this.getClass().getSimpleName(). Als het een anonieme klas is, gebruik dan this.getClass().getSuperclass().getName()

Antwoord 4, autoriteit 4%

Je kunt this.getClass().getSimpleName()gebruiken, zoals:

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

Antwoord 5

de combinatie van beide antwoorden. Drukt ook een methode-naam af:

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

Antwoord 6

Dit antwoord is laat, maar ik denk dat er een andere manier is om dit te doen in de context van anonieme handlersklasse.

Laten we zeggen:

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

Het zal hetzelfde resultaat bereiken. Bovendien is het eigenlijk behoorlijk gemak, omdat elke klasse wordt gedefinieerd bij compileertijd, dus geen dynamiciteit is beschadigd.

Hierboven, als de klasse echt is genest, d.w.z. AEigenlijk is ingesloten door B, kan de klasse van B eenvoudig bekend zijn als:

B.this.getClass().getName()

Antwoord 7

In uw voorbeeld verwijst thiswaarschijnlijk naar een anonieme klasse-instantie. Java geeft een naam aan die klassen door een $numbertoe te voegen aan de naam van de omsluitende klasse.

Antwoord 8

Hier is een Android-variant, maar hetzelfde principe kan ook in gewone Java worden gebruikt.

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

Antwoord 9

Ik neem aan dat dit gebeurt voor een anonieme klas. Wanneer je een anonieme klas aanmaakt, creëer je eigenlijk een klas die de klas uitbreidt waarvan je de naam hebt gekregen.

De “schonere” manier om de gewenste naam te krijgen is:

Als je klas een anonieme innerlijke klas is, zou getSuperClass()je de klas moeten geven waaruit deze is gemaakt. Als je het vanuit een interface hebt gemaakt, ben je een soort SOL, want het beste wat je kunt doen is getInterfaces(), wat je meer dan één interface kan geven.

De “hacky” manier is om gewoon de naam te krijgen met getClassName()en een regex te gebruiken om de $1te verwijderen.

Antwoord 10

In mijn geval gebruik ik deze Java-klasse:

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

Antwoord 11

Ik heb dit gevonden om voor mijn code te werken, maar mijn code krijgt de klasse uit een array in een voor lus.

String className="";
className = list[i].getClass().getCanonicalName();
System.out.print(className); //Use this to test it works

Antwoord 12

reflectie apis

Er zijn verschillende reflectie-apis die klassen retourneert, maar deze kunnen
alleen toegankelijk als een klasse al rechtstreeks is verkregen
of indirect.

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

Retourneert alle openbare klassen, interfaces en ENUM’s die leden zijn
van de klasse inclusief geërfde leden.

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

Karakter bevat twee ledenklassen karakter.Subset en
Karakter.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

teken.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

een insluitende klas hebben.

       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.