FATOS INTERESSANTES SOBRE NULL EM JAVA

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:

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.

Java

    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    .   
 Java      public     class   Test   {      private     static     Object     obj  ;         public     static     void     main  (  String     args  []  )      {      // it will print null;      System  .  out  .  println  (  &  quot  ;  Value     of     object     obj     is     :     &  quot  ;     +     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.   
 Java      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.   
 Java      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.   
 Java      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  (      &  quot  ;     static     method        can     be     called     by     null     reference     &     quot  ;);      }      private     void     nonStaticMethod  ()      {      // Can not be called by null reference      System  .  out  .  print  (  &  quot  ;      Non     -     static     method     -     &  quot  ;);      System  .  out  .  println  (      &  quot  ;      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.   
 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.  
 Java      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 '+' '    
 Java      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  );      }   }   
    
  Saída   Concatenated value : null_value