Comment vérifier le type de variable en Java?

Comment puis-je vérifier que ma variable est un int, un tableau, un double, etc ...?

Edit: Par exemple, comment puis-je vérifier qu'une variable est un tableau? Y a-t-il une fonction pour faire cela?

Java est un langage à typage statique, donc le compilateur effectue la plupart de cette vérification pour vous. Une fois que vous déclarez une variable comme étant d'un certain type, le compilateur s'assurera qu'elle ne reçoit que des valeurs de ce type (ou des valeurs qui sont des sous-types de ce type).

Les exemples que vous avez donnés ( int, array, double) sont tous des primitifs, et il n'y en a pas de sous-types. Ainsi, si vous déclarez une variable comme étant un int:

int x;

Vous pouvez être sûr qu'il ne contiendra jamais que des intvaleurs.

ListCependant, si vous avez déclaré une variable comme étant a , il est possible que la variable contienne des sous-types de List. Des exemples de ceux - ci comprennent ArrayList, LinkedListetc.

Si vous aviez une Listvariable et que vous aviez besoin de savoir si c'était une ArrayList, vous pouvez effectuer les opérations suivantes:

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

Cependant, si vous pensez que vous devez le faire, vous voudrez peut-être repenser votre approche. Dans la plupart des cas, si vous suivez les principes orientés objet, vous n'aurez pas besoin de le faire. Il y a, bien sûr, des exceptions à chaque règle, cependant.

En fait, il est assez facile de lancer votre propre testeur, en abusant de la capacité de surcharge de méthode de Java. Bien que je sois toujours curieux de savoir s'il existe une méthode officielle dans le SDK.

Exemple:

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

puis:

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

a.getClass().getName()- vous donnera le type de données de l'objet réel référencé par a, mais pas le type de données dans lequel la variable a aété initialement déclarée ou vers laquelle il a été converti ultérieurement.

boolean b = a instanceof String- vous indiquera si l'objet réel auquel fait référence aest une instance d'une classe spécifique. Encore une fois, le type de données dans lequel la variable aa été déclarée à l'origine ou vers laquelle il a été converti par la suite n'a aucune incidence sur le résultat de l'opérateur instanceof.

J'ai pris cette information de: Comment connaissez-vous un type de variable en java?

Cela peut arriver. J'essaie d'analyser un Stringdans un int et j'aimerais savoir si mon Integer.parseInt(s.substring(a, b))est en train de jeter un int ou une poubelle avant d'essayer de le résumer.

Au fait, c'est ce qu'on appelle la réflexion. Voici quelques informations supplémentaires sur le sujet: http://docs.oracle.com/javase/tutorial/reflect/

Vous pouvez travailler avec Integer au lieu de int, Double au lieu de double, etc. (de telles classes existent pour tous les types primitifs). Ensuite, vous pouvez utiliser l'opérateur instanceof, commeif(var instanceof Integer){...}

Utilisez simplement:

.getClass().getSimpleName();

Exemple:

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

Production:

StringBuilder

Eh bien, je pense que la vérification du type de variable peut être effectuée de cette façon.

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! ");
}

De cette façon, vous n'avez pas besoin d'avoir plusieurs méthodes surchargées. Je pense que c'est une bonne pratique d'utiliser des collections sur des tableaux en raison des avantages supplémentaires. Cela dit, je ne sais pas comment vérifier un type de tableau. Peut-être que quelqu'un peut améliorer cette solution. J'espère que cela t'aides!

PS Oui, je sais que cela ne vérifie pas non plus les primitives.

La première partie de votre question n'a pas de sens. Il n'y a aucune circonstance dans laquelle vous ne connaissez pas le type d'une variable primitive au moment de la compilation.

Concernant la deuxième partie, la seule circonstance où vous ne savez pas déjà si une variable est un tableau est si c'est un objet. Dans ce cas object.getClass().isArray(), vous le direz.

Je l'ai fait en utilisant: if(x.getClass() == MyClass.class){...}

Je n'étais satisfait d'aucune de ces réponses, et celle qui est juste n'a pas d'explication et des votes négatifs, alors j'ai cherché, trouvé des choses et les ai modifiées pour qu'elles soient faciles à comprendre. Jouez avec, pas aussi simple qu'on pourrait l'espérer.

//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);

Voici une méthode:

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

Aucune de ces réponses ne fonctionne si la variable est un type générique non initialisé

Et d'après ce que je peux trouver, ce n'est possible qu'en utilisant une solution de contournement extrêmement moche , ou en passant un paramètre initialisé à votre fonction, en le rendant en place, voir ici:

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

N'est PAS valide car vous ne pouvez pas extraire Tdirectement le type du paramètre, car il est effacé au moment de l'exécution.

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

Cela fonctionne car l'appelant est responsable de l'instanciation de la variable outavant l'appel. Cela lèvera toujours une exception si out est nul lorsqu'il est appelé, mais par rapport à la solution liée, c'est de loin le moyen le plus simple de le faire

Je sais que c'est une sorte d'application spécifique, mais comme c'est le premier résultat sur google pour trouver le type d'une variable avec java (et étant donné qu'il Ts'agit d'une sorte de variable), je pense qu'il devrait être inclus

Vous pouvez le vérifier facilement en utilisant Java.lang.Class.getSimpleName()Method Only si la variable a un type non primitif. Cela ne fonctionne pas avec les types primitifs int, long etc.

reference - Voici le lien des documents Oracle

En gros, par exemple:

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
    }

}

public class 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());

}

}