Todos y cada uno de los lenguajes de programación, incluido Java, están limitados por nulo. No hay ningún programador que no haya enfrentado ningún problema en el código relacionado con null. Los programadores se enfrentan principalmente Excepción de puntero nulo cuando intentan realizar algunas operaciones con datos nulos. NullPointerException es una clase disponible que pertenece al paquete java.lang.
Antes de comprender los hechos de null, es necesario tener conocimientos de las variables de Java. Si no sabes que variable java es decir, ingresa al siguiente enlace:
Todos y cada uno de los desarrolladores deben tener conocimiento sobre los siguientes hechos de nulo en Java:
Distingue mayúsculas y minúsculas
En Java, no podemos escribir nulo como NULL o 0 como en la programación C porque nulo es un literal y las palabras clave distinguen entre mayúsculas y minúsculas en Java.
Tomemos un ejemplo para comprender el comportamiento de nulo que distingue entre mayúsculas y minúsculas.
NullExample1.java
// import classes and packages if any public class NullExample1 { // main() method start public static void main (String[] args) throws java.lang.Exception { // declare and initialize an object with NULL Object obj1 = NULL; // declare and initialize an object with null Object obj2 = null; // print both objects System.out.println('The value of obj1 is: '+obj1); System.out.println('The value of obj2 is: '+obj2); } } Producción:
Valor de la variable de referencia
De forma predeterminada, todas y cada una de las variables de referencia tienen un valor nulo en Java. Una variable de referencia se utiliza para indicar y almacenar objetos/valores de tipo de referencia en Java. Clases, matrices, enumeraciones e interfaces, etc., son algunos tipos de referencia en Java.
Entonces, un tipo de referencia almacena un valor nulo si no se pasa ningún objeto a un tipo de referencia.
Tomemos un ejemplo para entender cómo funciona una variable de referencia para un valor nulo:
NullExample2.java
// import classes and packages if any public class NullExample2 { // declare two objects private static Object obj1; private static Object obj2; // main() method start public static void main (String[] args) { // print both objects System.out.println('The value of obj1 is: '+obj1); System.out.println('The value of obj2 is: '+obj2); } } Producción:
Tipo nulo
En Java, nulo no es ni un objeto ni un tipo. Es un valor especial que podemos asignar a cualquier variable de tipo referencia. Podemos convertir null en cualquier tipo que queramos, como string, int, double, etc.
Tomemos un ejemplo para comprender cómo podemos asignar valores nulos a cualquier tipo de referencia.
java agregando a una matriz
NullExample3.java
// import classes and packages if any public class NullExample3 { // main() method start public static void main (String[] args) { // pass a null value to a different type of variable // pass null to String String str = null; // pass null to Integer Integer itr = null; // pass null to Double Double dbl = null; // casting null to String String castedStr = (String)null; // casting null to Integer Integer castedItr = (Integer)null; // casting null to Double Double castedDbl = (Double)null; // print all reference type System.out.println('The value of str is: '+str); System.out.println('The value of itr is: '+itr); System.out.println('The value of dbl is: '+dbl); System.out.println('The value of castedStr is: '+castedStr); System.out.println('The value of castedItr is: '+castedItr); System.out.println('The value of castedDbl is: '+castedDbl); } } Producción:
Autoboxing y Unboxing
autoboxeo y Desembalaje son las dos operaciones más importantes que realizamos en Java. El compilador lanza Excepción de puntero nulo cuando asignamos un valor nulo a cualquier tipo de datos primitivos en cuadro mientras realizamos las operaciones.
Tomemos un ejemplo para comprender el autoboxing y el hecho de unboxing nulo.
NullExample4.java
// import classes and packages if any public class NullExample4 { // main() method start public static void main (String[] args) throws java.lang.Exception { // pass null value to a reference type Integer itr = null; // perform unboxing operation int data = itr; // print both objects System.out.println('The value of itr is: '+itr); System.out.println('The value of data is: '+data); } } Producción:
La instancia del operador
Para comprobar si un objeto es una instancia del tipo especificado o no, usamos el en vez de operador. El en vez de El operador devuelve verdadero cuando el valor de la expresión no es nulo en tiempo de ejecución. Desempeña un papel importante en los controles de encasillamiento.
Pongamos un ejemplo para entender en vez de operador:
NullExample5.java
// import classes and packages if any public class { // main() method start public static void main (String[] args) throws java.lang.Exception { // pass null value to a reference type Integer m = null; // pass a value to a reference type Integer n = 20; // print instanceof values System.out.println(m instanceof Integer); System.out.println(n instanceof Integer); } } Producción:
Estático vs. Métodos no estáticos
No podemos llamar a un método no estático en una variable de referencia con un valor nulo. Si lo llamamos, arrojará NullPointerException, pero podemos llamar al método estático con variables de referencia con valores nulos. Dado que los métodos estáticos se vinculan mediante enlace estático, no generarán una excepción de puntero nulo.
Tomemos un ejemplo para entender el hecho de nulo:
NullExample6.java
// import classes and packages if any public class NullExample6 { // define static method public static void staticMethod() { //it can be called by using a null reference System.out.println('static method can be called by null reference.'); } // define non static method public void nonStaticMethod() { //it cannot be called by using a null reference System.out.println('static method cannot be called by a null reference.'); } // main() method start public static void main (String[] args) throws java.lang.Exception { NullExample6 exp = null; exp.staticMethod(); exp.nonStaticMethod(); } } Producción:
== y != Operadores
En Java, estos dos operadores están permitidos con nulo. Ambos operadores son útiles para verificar nulos con objetos en Java.
Tomemos un ejemplo para comprender cómo funcionan estos dos operadores con nulo.
NullExample7.java
// import classes and packages if any public class NullExample7 { // main() method start public static void main (String[] args) { // pass null value to String type of variables // pass null to str1 String str1 = null; // pass null to str2 String str2 = null; // pass null to str3 String str3 = 'Test'; // compare strings if(str1 == str2){ System.out.println('str1 and str2 both are equal'); }else{ System.out.println('str1 and str2 are not equal'); } if(str2 == str3){ System.out.println('str2 and str3 both are equal'); }else{ System.out.println('str2 and str3 are not equal'); } if(str3 == str1){ System.out.println('str3 and str1 both are equal'); }else{ System.out.println('str3 and str1 are not equal'); } } } Producción:
¿Qué es la estructura en la estructura de datos?
Todos y cada uno de los desarrolladores de Java deben tener conocimiento de todos los hechos nulos discutidos anteriormente.