A melhor maneira de "negar" uma instância de

Eu estava pensando se existe uma maneira melhor / mais agradável de negar um instanceofem Java. Na verdade, estou fazendo algo como:

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

Mas acho que deveria existir uma sintaxe "bonita" para fazer isso.

Alguém sabe se existe e como é a sintaxe?

EDIT: Por bonito, eu poderia dizer algo como isto:

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

Não, não há melhor caminho; o seu é canônico.

Não sei o que você imagina quando diz "bonito", mas e quanto a isso? Pessoalmente, acho que é pior do que o formulário clássico que você postou, mas alguém pode gostar ...

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

Você pode usar o Class.isInstancemétodo:

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

... mas ainda é negado e muito feio.

Normalmente você não quer apenas ifuma elsecláusula, mas também.

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

pode ser escrito como

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

Ou você pode escrever o código para não precisar saber se é uma String ou não. por exemplo

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

pode ser escrito como

str = str.toString();

Se você pode usar importações estáticas e seu código moral permitir

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

E depois...

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 é apenas um exercício de interface fluente, eu nunca usaria isso no código da vida real!
Siga seu jeito clássico, não confundirá mais ninguém lendo seu código!

Se você achar mais compreensível, poderá fazer algo assim com o 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
}

ok apenas meus dois centavos, use um método é 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");
}

Você pode conseguir fazendo o procedimento abaixo: basta adicionar uma condição adicionando colchete if(!(condition with instanceOf))com toda a condição, adicionando o !operador no início da maneira mencionada nos trechos de código abaixo.

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

ao invés de

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

Concordo que, na maioria dos casos, if (!(x instanceof Y)) {...}é a melhor abordagem, mas, em alguns casos, cria uma isY(x)função para que você possaif (!isY(x)) {...} valer a pena.

Sou iniciante em datilografia, e me deparei com essa questão de S / O várias vezes nas últimas semanas; portanto, para os googlers, a maneira datilografada de fazer isso é criar uma proteção de tipo como esta:

typeGuards.ts

export function isHTMLInputElement (value: any): value is HTMLInputElement {
  return value instanceof HTMLInputElement
}

uso

if (!isHTMLInputElement(x)) throw new RangeError()
// do something with an HTMLInputElement

Eu acho que a única razão pela qual isso pode ser apropriado no texto datilografado e não no js comum é que as proteções tipográficas são uma convenção comum; portanto, se você as escreve para outras interfaces, é razoável / compreensível / natural escrevê-las também para as aulas.

Há mais detalhes sobre proteções de tipo definidas pelo usuário nos documentos