Truques e dicas. Como evitar NullPointerException em aplicativos Java

Hoje vou mostrar técnicas simples de como evitar NullPointerException em suas aplicações. Eles são fáceis de seguir, mas melhoram significativamente a confiabilidade e a qualidade do seu código. Além disso, na minha experiência, a primeira dica terá um impacto perceptível na qualidade do seu código. Se você conhece algum outro truque de programação Java, sinta-se à vontade para compartilhá-lo nos comentários.

Chame os métodos equals() e equalsIgnoreCase() em uma string literal conhecida em vez de um objeto desconhecido

Sempre chame um método equals()em uma string conhecida que você sabe que não é null. O método equals()é simétrico, ou seja, chama a.equals(b)e b.equals(a)dará o mesmo resultado (if ae bnot null), e por isso muitos programadores não prestam atenção em quais objetos são chamados equals(), y aou y b. Um dos efeitos colaterais disso é um NullPointerException se o método for chamado null.

Object unknownObject = null;

//плохой способ - может вызвать NullPointerException
if(unknownObject.equals("knownObject")){
   System.err.println("This may result in NullPointerException if unknownObject is null");
}

//правильный способ - исключение NullPointerException не возникнет, даже если unknownObject null
if("knownObject".equals(unknownObject)){
    System.err.println("better coding avoided NullPointerException");
}

Essa foi a dica mais simples para evitar NullPointerException, mas por si só já representa uma grande melhoria porque o método equals()é encontrado em todos os lugares.

Escolha valueOf() em vez de toString() nos casos em que ambos produzem o mesmo resultado

Como chamar toString()uma referência com um valor nullgera uma NullPointerException, é melhor usar call valueOf()quando pudermos obter o mesmo resultado, já que chamar valueOf()from nullreturn null. Isso é especialmente verdadeiro para classes wrapper como Integer, Float, Doubleou BigDecimal.

BigDecimal bd = getPrice();
System.out.println(String.valueOf(bd)); //не выбрасывает NPE
System.out.println(bd.toString()); //выбрасывает "Exception in thread "main" java.lang.NullPointerException"

Use essas dicas quando não tiver certeza se um objeto pode existir nullou não.

Use nullmétodos e bibliotecas -safe

Existem muitas bibliotecas de código aberto que assumem a pesada carga de testes do null. Um dos mais comuns é StringUtilsdo Apache Commons. Usando métodos como StringUtils.isBlank(), isNumeric(), isWhiteSpace()etc. você não precisa se preocupar em lançar um NullPointerException.

//Методы StringUtils являются null-безопасными, они не вызовут NullPointerException
System.out.println(StringUtils.isEmpty(null));
System.out.println(StringUtils.isBlank(null));
System.out.println(StringUtils.isNumeric(null));
System.out.println(StringUtils.isAllUpperCase(null));

Saída: verdadeiro verdadeiro falso falso E ainda assim, antes de usar, não esqueça de ler a documentação nullde métodos e classes seguros. Este é outro dos melhores truques do Java que leva a grandes melhorias sem exigir muito esforço.

Tente não retornar nullde um método, é melhor retornar uma coleção vazia

Esta é outra boa dica de programação Java que Joshua Bloch descreve em seu livro Java: Effective Programming. Ao retornar coleções ou matrizes vazias, certifique-se de que chamar métodos base goste size()ou length()não de lançar uma NullPointerException. A classe Collectionsdeclara especificamente implementações convenientes de listas, conjuntos e dicionários vazios Collections.EMPTY_LIST: Collections.EMPTY_SETe Collections.EMPTY_MAP. Por exemplo:

public List getOrders(Customer customer){
   List result = Collections.EMPTY_LIST;
   return result;
}

Da mesma forma, você pode usá Collections.EMPTY_SET-lo Collections.EMPTY_MAPem vez de retornar null.

Use anotações @NotNull e @Nullable

Na descrição dos seus métodos, você pode definir nullconvenções de segurança do método usando anotações @NotNulle @Nullable para indicar se um método pode retornar nullou não. Compiladores e IDEs modernos podem usar essas anotações para analisar seu código e fornecer conselhos apropriados, por exemplo, sobre a falta de uma verificação de null, ou vice-versa, sobre a possibilidade de remover uma verificação desnecessária que está obstruindo o código. Tais anotações, por exemplo, são suportadas pelo IDE IntelliJ e FindBugs, e também estão incluídas no JSR 305. Mas mesmo que o seu IDE não suporte tais anotações, elas serão uma boa documentação por si só. Olhando @NotNulle @Nullableserá mais fácil para o programador entender onde adicionar um cheque nulle onde não. A propósito, essa é uma prática relativamente nova entre os programadores Java e levará algum tempo para se espalhar.

Evite autoboxing e autounboxing desnecessários em seu código

Isso não apenas leva à criação de objetos temporários desnecessários, mas o autoboxing também pode gerar uma NullPointerException se a classe wrapper for null. Por exemplo, o código a seguir lançará uma NullPointerException se a entrada da pessoa não contiver um número de telefone e retornar null.

Person ram = new Person("ram");
int phone = ram.getPhone();

Ao usar autoboxing ou autounboxing, não apenas igualdades, mas também desigualdades <> >podem resultar em uma NullPointerException.

Siga as convenções e defina padrões razoáveis.

Uma das melhores maneiras de evitar NullPointerException em Java é declarar e seguir adequadamente as convenções de codificação. A maioria das NullPointerExceptions ocorre quando você tenta criar um objeto sem ter todos os dados e dependências necessários. Ao evitar a criação de objetos inacabados, rejeitando normalmente tais solicitações, você se salvará de um grande número de NullPointerExceptions no futuro. Da mesma forma, se você permitir a criação de objetos, deverá escolher um valor padrão razoável. Por exemplo, um objeto de classe Employeenão pode ser criado sem um nome e id, mas pode não ter um número de telefone. Nesse caso, objetos Employeesem número podem retornar zero null. Embora tal comportamento do objeto deva ser pensado com antecedência - pode ser mais fácil verificar nulldo que ligar para um número inexistente. Nesse caso, ter condições adicionais sobre quais campos são nulle quais não são ajudará a tomar a decisão certa. Em geral, a escolha entre travar imediatamente o programa ou atribuí- nulllo é uma decisão importante de design e, depois de fazer a escolha, você deve segui-la de forma consistente.

Definir restrições no nível do DBMS

Ao usar um banco de dados para armazenar seus objetos de programa, como Clientes ou Pedidos, é aconselhável especificar a " nullness" de seus objetos no nível do SGBD, usando restrições de tabela apropriadas. Os bancos de dados geralmente contêm informações de várias fontes, e a introdução de verificações de valores ausentes melhorará a integridade dos seus dados. Além disso, a presença de verificações de null no nível do SGBD irá reduzi-las em seu código Java: ao carregar dados do banco de dados em objetos Java, você pode ter certeza de sua presença e remover "" desnecessários != nulldo código do programa.

Use o padrão de objeto nulo

Criar Nullobjetos especiais é outra maneira de evitar NullPointerExcpetion em Java. Vamos supor que algum método em nosso aplicativo retorne um objeto com o qual o programa trabalhará posteriormente, chamando seus métodos. Por exemplo, o método Collection.iterator()retorna um objeto da classe Iteratorque é usado para iterar pela coleção. Então, se o objeto original não tiver nenhum iterador, nullvocê poderá retornar um Nullobjeto especial que possui um método hasNext()que sempre retorna false. Isso é tudo, caro leitor, é aqui que termino minhas dicas para livrar programas Java de erros de NullPointerException. Você apreciará o quão úteis essas regras simples e não pesadas podem ser. Como lembrete, se você quiser compartilhar quaisquer outros truques de NullPointerException em programas Java, sinta-se à vontade para fazê-lo nos comentários. Traduzido especificamente para alunos JavaRush. Original