FATTI INTERESSANTI SU NULL IN JAVA

Quasi tutti i linguaggi di programmazione sono legati a null. Non c'è quasi un programmatore che non sia turbato da null. In Java null è associato a java.lang. NullPointerException . Essendo una classe nel pacchetto java.lang, viene chiamata quando proviamo a eseguire alcune operazioni con o senza null e talvolta non sappiamo nemmeno dove sia successo. Di seguito sono riportati alcuni punti importanti su null in Java che ogni programmatore Java dovrebbe conoscere:

In Java null è un valore speciale che rappresenta l'assenza di un valore o di un riferimento. Viene utilizzato per indicare che a una variabile o a un oggetto non è attualmente assegnato un valore.
Il valore null non è uguale a una stringa vuota o a un array vuoto. Una stringa vuota è una stringa che non contiene caratteri mentre un array vuoto è un array che non contiene elementi.
Il linguaggio di programmazione Java ha un tipo null incorporato chiamato "null" che è un sottotipo di tutti i tipi di riferimento. Tuttavia non può essere utilizzato come tipo per una variabile perché non ha alcuna istanza e non può essere istanziata.
È considerata una procedura consigliata verificare la presenza di valori nulli prima di eseguire qualsiasi operazione su di essi per evitare il rischio di NullPointerException (NPE). NPE è considerata una delle eccezioni più comuni in Java e può causare comportamenti imprevisti o arresti anomali di un programma.
In Java null viene utilizzato anche per indicare che un metodo non restituisce alcun valore. Questo è noto come tipo di ritorno "void". Un metodo void non restituisce alcun valore e viene generalmente utilizzato per eseguire un'azione come la stampa sulla console o l'aggiornamento di un database.
Inoltre null può essere utilizzato come valore predefinito per i parametri facoltativi in un metodo. Ciò consente di chiamare un metodo senza specificare un valore per quel parametro e verrà invece utilizzato il valore null.
Non è consigliabile utilizzare null come valore per una variabile o un oggetto destinato a contenere un valore di un tipo di dati primitivo come int o double perché causerebbe un errore in fase di compilazione.
L'uso di null in Java può essere fonte di confusione e bug sottili, quindi è importante essere consapevoli del suo comportamento e di come gestirlo correttamente nel codice per evitare errori.

1. null fa distinzione tra maiuscole e minuscole: null è letterale in Java e poiché le parole chiave lo sono maiuscole e minuscole in Java non possiamo scrivere NULL o 0 come nel linguaggio 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  ;         }   }

Produzione:

 5: error: cannot find symbol   
  can't find symbol 'NULL'   
  ^   
  variable NULL   
  class Test   
 1 error       2. Valore della variabile di riferimento:    Qualsiasi variabile di riferimento in Java ha un valore predefinito     nullo    .   
 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  );      }      }   
    Produzione:  
  Value of object obj is : null       3. Tipo di nullo:    A differenza del malinteso comune, null non è Object e nemmeno un tipo. È solo un valore speciale che può essere assegnato a qualsiasi tipo di riferimento e puoi digitare cast null su qualsiasi tipo Esempi:  
   // 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 le operazioni di auto-boxing e unboxing, il compilatore genera semplicemente un errore di eccezione Nullpointer se un valore nullo viene assegnato al tipo di dati primitivo boxed.   
 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  ;      }   }   
    Produzione:  
   Exception in thread 'main' java.lang.NullPointerException   
  at Test.main(Test.java:6)       5. istanza dell'operatore:    L'operatore Java exampleof viene utilizzato per verificare se l'oggetto è un'istanza del tipo specificato (classe, sottoclasse o interfaccia). In fase di esecuzione il risultato dell'operatore istanzaof è vero se il valore dell'espressione non è null. Questa è una proprietà importante dell'operazione istanza che la rende utile per i controlli di conversione del 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  );      }   }   
    Produzione:  
  false    
 true      6. Metodi statici e non statici:    Non possiamo chiamare un metodo non statico su una variabile di riferimento con valore nullo, lancerà NullPointerException ma possiamo chiamare un metodo statico con variabili di riferimento con valori nulli. Poiché i metodi statici sono collegati utilizzando l'associazione statica, non genereranno un'eccezione del puntatore Null.   
 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  ;);      }   }   
    Produzione:  
  static method can be called by null referenceException in thread 'main'    
 java.lang.NullPointerException   
  at Test.main(Test.java:5)       7. == e !=    Il confronto e gli operatori diverso da uguale a sono consentiti con null in Java. Ciò può essere utile nel controllo di null con oggetti in 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  );      }   }   
    Produzione:  
  true   
 false      8    .     'null' può essere passato come argomento nel metodo:    
  Possiamo passare il null come argomento in Java e possiamo stampare lo stesso. Il tipo di dati dell'argomento dovrebbe essere Tipo di riferimento. Ma il tipo di metodo restituito potrebbe essere qualsiasi tipo come void int double o qualsiasi altro tipo di riferimento a seconda della logica del programma.  
  Qui il metodo 'print_null' stamperà semplicemente l'argomento passato dal metodo principale.  
 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  );      }   }   
       Produzione :    
      Ehi, sono: nullo    
 
     9. Operatore '+' su null :    
  Possiamo concatenare il valore null con le variabili String in Java. È considerata una concatenazione in Java.  
  Qui il null sarà concatenato solo con la variabile String. Se utilizziamo l'operatore '+' con null e qualsiasi altro tipo (intero doppio ecc.) diverso da String, verrà generato un messaggio di errore.   
  L'intero a=null+7 genererà un messaggio di errore come '     tipi di operandi errati per l'operatore binario '+' '    
 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  );      }   }   
    
  Produzione   Concatenated value : null_value