Quase todas as linguagens de programação estão vinculadas a null. Dificilmente existe um programador que não se preocupe com null. Em Java, nulo está associado a java.lang. NullPointerException . Por ser uma classe do pacote java.lang ela é chamada quando tentamos realizar alguma operação com ou sem null e às vezes nem sabemos onde isso aconteceu. Abaixo estão alguns pontos importantes sobre null em java que todo programador Java deve saber: 

número do palíndromo

• Em Java, null é um valor especial que representa a ausência de um valor ou referência. É usado para indicar que uma variável ou objeto não possui atualmente um valor atribuído a ele.
• O valor nulo não é o mesmo que uma string vazia ou uma matriz vazia. Uma string vazia é uma string que não contém caracteres, enquanto uma matriz vazia é uma matriz que não contém elementos.
• A linguagem de programação Java possui um tipo nulo integrado chamado 'null', que é um subtipo de todos os tipos de referência. No entanto, não pode ser usado como tipo para uma variável porque não possui nenhuma instância e não pode ser instanciado.
• É considerada uma prática recomendada verificar valores nulos antes de executar qualquer operação neles para evitar o risco de uma NullPointerException (NPE). O NPE é considerado uma das exceções mais comuns em Java e pode causar comportamento inesperado ou travamentos em um programa.
• Em Java, null também é usado para indicar que um método não retorna nenhum valor. Isso é conhecido como tipo de retorno 'void'. Um método void não retorna nenhum valor e normalmente é usado para executar uma ação como imprimir no console ou atualizar um banco de dados.
• Além disso, null pode ser usado como valor padrão para parâmetros opcionais em um método. Isso permite que um método seja chamado sem especificar um valor para esse parâmetro e o valor nulo será usado em seu lugar.
• Não é recomendado usar null como valor para uma variável ou objeto que se destina a conter um valor de um tipo de dados primitivo, como int ou double, porque isso causará um erro em tempo de compilação.
• O uso de null em Java pode ser uma fonte de confusão e bugs sutis, por isso é importante estar ciente de seu comportamento e como tratá-lo adequadamente em seu código para evitar erros.

1. null diferencia maiúsculas de minúsculas: null é literal em Java e porque as palavras-chave são maiúsculas e minúsculas em java não podemos escrever NULL ou 0 como na linguagem C. 

public class Test {  public static void main (String[] args) throws java.lang.Exception  {  // compile-time error : can't find symbol 'NULL'  Object obj = NULL;     //runs successfully  Object obj1 = null;   } } 

Saída:

5: error: cannot find symbol  
 can't find symbol 'NULL'  
 ^  
 variable NULL  
 class Test  
1 error 

2. Valor da variável de referência: Qualquer variável de referência em Java tem um valor padrão nulo . 

public class Test {  private static Object obj;   public static void main(String args[])  {  // it will print null;  System.out.println("Value of object obj is : " + obj);  }  } 

Saída:

Value of object obj is : null 

3. Tipo de nulo: Ao contrário do equívoco comum, null não é Object nem é um tipo. É apenas um valor especial que pode ser atribuído a qualquer tipo de referência e você pode digitar cast null para qualquer tipo. Exemplos:

 // null can be assigned to String  
 String str = null;   
   
 // you can assign null to Integer also  
 Integer itr = null;   
   
 // null can also be assigned to Double  
 Double dbl = null;   
   
 // null can be type cast to String  
 String myStr = (String) null;   
   
 // it can also be type casted to Integer  
 Integer myItr = (Integer) null;   
   
 // yes it's possible no error  
 Double myDbl = (Double) null; 

4. Autoboxing e unboxing: Durante as operações de auto-boxing e unboxing, o compilador simplesmente lança um erro de exceção Nullpointer se um valor nulo for atribuído ao tipo de dados primitivo em caixa. 

public class Test {  public static void main(String[] args)  throws java.lang.Exception  {  // An integer can be null so this is fine  Integer i = null;  // Unboxing null to integer throws  // NullpointerException  int a = i;  } } 

Saída:

 Exception in thread 'main' java.lang.NullPointerException  
 at Test.main(Test.java:6) 

5. operador de instância: O operador java instanceof é usado para testar se o objeto é uma instância do tipo especificado (classe ou subclasse ou interface). Em tempo de execução, o resultado do operador instanceof será verdadeiro se o valor da Expressão não for nulo. Esta é uma propriedade importante da operação instanceof que a torna útil para verificações de conversão de tipo. 

public class Test {  public static void main(String[] args)  throws java.lang.Exception  {  Integer i = null;  Integer j = 10;  // prints false  System.out.println(i instanceof Integer);  // Compiles successfully  System.out.println(j instanceof Integer);  } } 

Saída:

false   
true

6. Métodos estáticos versus não estáticos: Não podemos chamar um método não estático em uma variável de referência com valor nulo, pois isso lançará NullPointerException, mas podemos chamar um método estático com variáveis ​​de referência com valores nulos. Como os métodos estáticos são vinculados usando ligação estática, eles não lançarão exceção de ponteiro nulo. 

public class Test {  public static void main(String args[])  {  Test obj = null;  obj.staticMethod();  obj.nonStaticMethod();  }  private static void staticMethod()  {  // Can be called by null reference  System.out.println(  " static method  can be called by null reference & quot;);  }  private void nonStaticMethod()  {  // Can not be called by null reference  System.out.print("  Non - static method - ");  System.out.println(  "  cannot be called by null reference & quot;);  } } 

Saída:

static method can be called by null referenceException in thread 'main'   
java.lang.NullPointerException  
 at Test.main(Test.java:5) 

7. == e != A comparação e os operadores diferentes de são permitidos com null em Java. Isso pode ser útil na verificação de nulo com objetos em java. 

public class Test {  public static void main(String args[])  {  // return true;  System.out.println(null == null);  // return false;  System.out.println(null != null);  } } 

Saída:

true  
false

8 . 'null' pode ser passado como argumento no método:

Podemos passar o nulo como argumento em java e imprimir o mesmo. O tipo de dados do argumento deve ser Tipo de Referência. Mas o tipo de retorno do método pode ser qualquer tipo como void int double ou qualquer outro tipo de referência, dependendo da lógica do programa.

Aqui o método 'print_null' simplesmente imprimirá o argumento que é passado do método principal.

import java.io.*; class GFG {  public static void print_null(String str)  {  System.out.println('Hey I am : ' + str);  }  public static void main(String[] args)  {  GFG.print_null(null);  } } 

Saída :

Ei, eu sou: nulo

9. Operador '+' em null:

Podemos concatenar o valor nulo com variáveis ​​String em java. É considerada uma concatenação em java.

Aqui o nulo só será concatenado com a variável String. Se usarmos o operador '+' com null e qualquer outro tipo (Integer Double etc.) diferente de String, será gerada uma mensagem de erro. 

Inteiro a=null+7 gerará uma mensagem de erro como ' tipos de operandos ruins para operador binário '+' '

import java.io.*; class GFG {  public static void main(String[] args)  {  String str1 = null;  String str2 = '_value';  String output = str1 + str2;  System.out.println('Concatenated value : '  + output);  } } 

Concatenated value : null_value