Wie überprüfe ich den Variablentyp in Java?

Wie kann ich überprüfen, ob meine Variable int, array, double usw. ist?

Bearbeiten: Wie kann ich beispielsweise überprüfen, ob eine Variable ein Array ist? Gibt es eine Funktion, um dies zu tun?

Java ist eine statisch typisierte Sprache, daher führt der Compiler den größten Teil dieser Überprüfung für Sie durch. Sobald Sie eine Variable als einen bestimmten Typ deklarieren, stellt der Compiler sicher, dass ihr immer nur Werte dieses Typs zugewiesen werden (oder Werte, die Untertypen dieses Typs sind).

Die Beispiele, die Sie angegeben haben ( int, Array, double), sind alle Grundelemente, und es gibt keine Untertypen davon. Wenn Sie also eine Variable als int: deklarieren :

int x;

Sie können sicher sein, dass es immer nur intWerte enthält.

Wenn Sie eine Variable als a deklariert haben List, enthält die Variable möglicherweise Untertypen von List. Beispiele hierfür sind ArrayList, LinkedListusw.

Wenn Sie eine ListVariable hatten und wissen mussten, ob es sich um eine Variable handelt, können Sie ArrayListFolgendes tun:

List y;
...
if (y instanceof ArrayList) { 
  ...its and ArrayList...
}

Wenn Sie jedoch der Meinung sind, dass Sie dies tun müssen, sollten Sie Ihren Ansatz überdenken. In den meisten Fällen müssen Sie dies nicht tun, wenn Sie objektorientierten Prinzipien folgen. Es gibt natürlich Ausnahmen zu jeder Regel.

Eigentlich ganz einfach, einen eigenen Tester zu rollen, indem man die Fähigkeit von Java zur Methodenüberladung missbraucht. Obwohl ich immer noch neugierig bin, ob es eine offizielle Methode im SDK gibt.

Beispiel:

class Typetester {
    void printType(byte x) {
        System.out.println(x + " is an byte");
    }
    void printType(int x) {
        System.out.println(x + " is an int");
    }
    void printType(float x) {
        System.out.println(x + " is an float");
    }
    void printType(double x) {
        System.out.println(x + " is an double");
    }
    void printType(char x) {
        System.out.println(x + " is an char");
    }
}

dann:

Typetester t = new Typetester();
t.printType( yourVariable );

a.getClass().getName()- gibt Ihnen den Datentyp des tatsächlichen Objekts an, auf das verwiesen wird a, jedoch nicht den Datentyp, für den die Variable aursprünglich deklariert oder anschließend umgewandelt wurde.

boolean b = a instanceof String- gibt an, ob das tatsächliche Objekt, auf das verwiesen awird, eine Instanz einer bestimmten Klasse ist. Auch hier hat der Datentyp, für den die Variable aursprünglich deklariert oder anschließend umgewandelt wurde, keinen Einfluss auf das Ergebnis der Instanz des Operators.

Ich habe diese Informationen entnommen aus: Woher kennen Sie einen Variablentyp in Java?

Das kann passieren. Ich versuche, Stringein Int in ein Int zu analysieren, und ich würde gerne wissen, ob ich Integer.parseInt(s.substring(a, b))ein Int oder einen Müll rausschmeiße, bevor ich versuche, es zusammenzufassen.

Dies ist übrigens als Reflexion bekannt. Hier finden Sie weitere Informationen zu diesem Thema: http://docs.oracle.com/javase/tutorial/reflect/

Sie können mit Integer anstelle von int, Double anstelle von double usw. arbeiten (solche Klassen existieren für alle primitiven Typen). Dann können Sie die Operator-Instanz von wie verwendenif(var instanceof Integer){...}

Benutz einfach:

.getClass().getSimpleName();

Beispiel:

StringBuilder randSB = new StringBuilder("just a String");
System.out.println(randSB.getClass().getSimpleName());

Ausgabe:

StringBuilder

Ich denke, die Überprüfung des Variablentyps kann auf diese Weise erfolgen.

public <T extends Object> void checkType(T object) {    
    if (object instanceof Integer)
        System.out.println("Integer ");
    else if(object instanceof Double)
        System.out.println("Double ");
    else if(object instanceof Float)
        System.out.println("Float : ");
    else if(object instanceof List)
        System.out.println("List! ");
    else if(object instanceof Set)
        System.out.println("Set! ");
}

Auf diese Weise müssen Sie nicht mehrere überladene Methoden haben. Ich denke, es ist aufgrund der zusätzlichen Vorteile eine gute Praxis, Sammlungen über Arrays zu verwenden. Trotzdem weiß ich nicht, wie ich nach einem Array-Typ suchen soll. Vielleicht kann jemand diese Lösung verbessern. Hoffe das hilft!

PS Ja, ich weiß, dass dies auch nicht nach Grundelementen sucht.

Der erste Teil Ihrer Frage ist bedeutungslos. Es gibt keinen Umstand, unter dem Sie den Typ einer primitiven Variablen zur Kompilierungszeit nicht kennen.

Zum zweiten Teil ist der einzige Umstand, dass Sie noch nicht wissen, ob eine Variable ein Array ist, wenn es sich um ein Objekt handelt. In welchem ​​Fall object.getClass().isArray()wird es Ihnen sagen.

Ich habe es gemacht mit: if(x.getClass() == MyClass.class){...}

Ich war mit keiner dieser Antworten zufrieden, und die richtige hat keine Erklärung und keine negativen Stimmen, also habe ich mich umgesehen, ein paar Sachen gefunden und sie so bearbeitet, dass sie leicht zu verstehen sind. Spielen Sie damit, nicht so einfach, wie man es sich erhoffen würde.

//move your variable into an Object type
Object obj=whatYouAreChecking;
System.out.println(obj);

// moving the class type into a Class variable
Class cls=obj.getClass();
System.out.println(cls);

// convert that Class Variable to a neat String
String answer = cls.getSimpleName();
System.out.println(answer);

Hier ist eine Methode:

public static void checkClass (Object obj) {
    Class cls = obj.getClass();
    System.out.println("The type of the object is: " + cls.getSimpleName());       
}

Keine dieser Antworten funktioniert, wenn die Variable ein nicht initialisierter generischer Typ ist

Und soweit ich das beurteilen kann, ist es nur möglich, eine extrem hässliche Problemumgehung zu verwenden oder einen initialisierten Parameter an Ihre Funktion zu übergeben, um sie an Ort und Stelle zu machen. Siehe hier:

<T> T MyMethod(...){ if(T.class == MyClass.class){...}}

Ist NICHT gültig, da Sie den Typ nicht Tdirekt aus dem Parameter ziehen können, da er zur Laufzeit gelöscht wird.

<T> void MyMethod(T out, ...){ if(out.getClass() == MyClass.class){...}}

Dies funktioniert, weil der Aufrufer dafür verantwortlich ist, die Variable outvor dem Aufruf zu instanziieren . Dies löst immer noch eine Ausnahme aus, wenn out beim Aufruf null ist. Im Vergleich zur verknüpften Lösung ist dies jedoch bei weitem der einfachste Weg, dies zu tun

Ich weiß, dass dies eine Art spezifische Anwendung ist, aber da dies das erste Ergebnis bei Google ist, um den Typ einer Variablen mit Java zu finden (und da dies Teine Art Variable ist), sollte sie meiner Meinung nach enthalten sein

Sie können dies einfach mit Java.lang.Class.getSimpleName()Method Only überprüfen, wenn die Variable einen nicht primitiven Typ hat. Es funktioniert nicht mit primitiven Typen int, long usw.

Referenz - Hier ist der Link zu den Oracle-Dokumenten

Grundsätzlich zum Beispiel:

public class Kerem
{
    public static void main(String[] args)
    {
        short x = 10;
        short y = 3;
        Object o = y;
        System.out.println(o.getClass()); // java.lang.Short
    }

}

öffentliche Klasse Demo1 {

Object printType(Object o)
{
    return o;
}
 public static void main(String[] args) {

    Demo1 d=new Demo1();
    Object o1=d.printType('C');
    System.out.println(o1.getClass().getSimpleName());

}

}}