web-dev-qa-db-fra.com

Meilleure façon de "nier" une instance de

Je pensais que s’il existait un moyen meilleur/plus agréable d’annuler une instanceof en Java . En fait, je fais quelque chose du genre:

if(!(str instanceof String)) { /* do Something */ }

Mais je pense qu'une "belle" syntaxe pour faire cela devrait exister.

Est-ce que quelqu'un sait s'il existe et à quoi ressemble la syntaxe?

EDIT: Par beau, je pourrais dire quelque chose comme ceci:

if(str !instanceof String) { /* do Something */ } // compilation fails
javasyntax
341
caarlos0

Non, il n'y a pas de meilleur moyen. le vôtre est canonique.

266
maerics

Je ne sais pas ce que vous imaginez quand vous dites "beau", mais qu'en est-il? Personnellement, je pense que c'est pire que la forme classique que vous avez postée, mais quelqu'un pourrait l'aimer ...

if (str instanceof String == false) { /* ... */ }
112
Natix

Vous pouvez utiliser la méthode Class.isInstance :

if(!String.class.isInstance(str)) { /* do Something */ }

... mais c'est encore nié et assez moche.

49
dacwe

Généralement, vous ne voulez pas seulement une clause if, mais également une clause else.

if(!(str instanceof String)) { /* do Something */ } 
else { /* do something else */ }

peut être écrit comme

if(str instanceof String) { /* do Something else */ } 
else { /* do something */ }

Ou vous pouvez écrire le code afin de ne pas avoir besoin de savoir si c'est une chaîne ou non. par exemple.

if(!(str instanceof String)) { str = str.toString(); }

peut être écrit comme

str = str.toString();
18
Peter Lawrey

Si vous pouvez utiliser des importations statiques et que votre code moral le permet

public class ObjectUtils {
    private final Object obj;
    private ObjectUtils(Object obj) {
        this.obj = obj;
    }

    public static ObjectUtils thisObj(Object obj){
        return new ObjectUtils(obj);
    }

    public boolean isNotA(Class<?> clazz){
        return !clazz.isInstance(obj);
    }
}

Et alors...

import static notinstanceof.ObjectUtils.*;

public class Main {

    public static void main(String[] args) {
        String a = "";
        if (thisObj(a).isNotA(String.class)) {
            System.out.println("It is not a String");
        }
        if (thisObj(a).isNotA(Integer.class)) {
            System.out.println("It is not an Integer");
        }
    }    
}

Ceci est juste un exercice d’interface fluide, je n’utiliserais jamais cela dans un code réel!
Optez pour votre méthode classique, cela ne dérangera personne qui lit votre code!

12
Pablo Grisafi

ok juste mes deux cents, utilisez une méthode is string:

public static boolean isString(Object thing) {
    return thing instanceof String;
}

public void someMethod(Object thing){
    if (!isString(thing)) {
        return null;
    }
    log.debug("my thing is valid");
}
3
tibi

Si vous trouvez cela plus compréhensible, vous pouvez faire quelque chose comme ceci avec Java 8: 

Predicate<Object> isInstanceOfTheClass = 
    objectToTest -> objectToTest instanceof TheClass;

Predicate<Object> isNotInstanceOfTheClass = 
    isInstanceOfTheClass.negate(); // or objectToTest -> !(objectToTest instanceof TheClass)

if (notInstanceOfTheClass.test(myObject)) {
    // do something
}
1
Paul.F-G