La mejor manera de “negar” una instancia de

Question 1

Estaba pensando si existe una forma mejor/mejor para negar un instanceof en Java. En realidad, estoy haciendo algo como:

if(!(myObject instanceof SomeClass)) { /* do Something */ }

Pero creo que debería existir una sintaxis “hermosa” para hacer esto.

¿Alguien sabe si existe y cómo se ve la sintaxis?

EDITAR:
Por hermoso, podría decir algo como esto:

if(myObject !instanceof SomeClass) { /* do Something */ } // compilation fails

Question 2

No, no hay mejor manera; el tuyo es canónico.

Question 3

No sé qué imaginas cuando dices “hermoso”, pero ¿y esto? Personalmente, creo que es peor que la forma clásica que publicaste, pero a alguien le podría gustar…

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

Question 4

Podrías usar el Class.isInstance método:

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

… pero todavía es negado y bastante feo.

Question 5

Por lo general, no desea solo un if pero un else cláusula también.

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

Se puede escribir como

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

O puede escribir el código para que no necesite saber si es una cadena o no. p.ej

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

Se puede escribir como

str = str.toString();

Question 6

Si puede usar importaciones estáticas y su código moral lo permite

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

Y entonces…

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

Este es solo un ejercicio de interfaz fluida, ¡nunca lo usaría en el código de la vida real!
Elija su forma clásica, ¡no confundirá a nadie más que lea su código!

Question 7

Si lo encuentra más comprensible, puede hacer algo como esto con Java 8:

public static final Predicate<Object> isInstanceOfTheClass = 
    objectToTest -> objectToTest instanceof TheClass;

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

if (isNotInstanceOfTheClass.test(myObject)) {
    // do something
}

Question 8

ok, solo mis dos centavos, use un método de cadena is:

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

¿Ha sido útil esta solución?