JRL escribió:
No, no es, ...
Como suele ocurrir, depende de dónde lo mires, en quién creas más.
Según la JLS, sí, lo es . Especialmente si reformula la pregunta como: "¿Es el nullliteral de tipo Object?". Además de JLS 4.1 citado anteriormente por Michael Borgwardt:
Consulte JLS 3.10.7 :
Un literal nulo es siempre de tipo nulo.
y JLS 4.10 :
Los subtipos de un tipo T son todos tipos U, de manera que T es un supertipo de U y el tipo nulo.
o JLS 4.10.2 :
Los supertipos directos del tipo nulo son todos tipos de referencia distintos del tipo nulo en sí.
[Énfasis mío.]
Según el compilador de Eclipse 2019-09 no es :
true.toString(); // Cannot invoke toString() on the primitive type boolean
null.toString(); // Cannot invoke toString() on the primitive type null
Según OpenJDKs 12.0.1 javac es :
true.toString(); // error: boolean cannot be dereferenced
null.toString(); // error: <null> cannot be dereferenced
Donde los paréntesis angulares implican que nulles de un tipo distinto de primitivo. Y según JLS 4.1 :
Hay dos tipos de tipos en el lenguaje de programación Java: tipos primitivos (...) y tipos de referencia (...).
si no es el uno es el otro.
Claudiu escribió:
null es algo feo.
Au contraire, nulles hermoso. ¿Qué sugeriría como valor predeterminado para una variable de tipo de referencia? ¿Una combinación de bits arbitraria? ¡Bienvenido a la infracción de acceso o, peor aún, al infierno de punteros!
Joachim Sauer escribió:
null es un tipo y un valor.
En realidad, hay tres elementos junto con null (consulte también JLS 3.10.7 ):
- El tipo nulo (de lo contrario sin nombre) .
- El
null literal .
- El valor de referencia nulo . (Comúnmente abreviado como valor nulo o simplemente nulo ).
(1) Tenga en cuenta que, de acuerdo con JLS 4.10.2 citado anteriormente, el tipo nulo usa herencia múltiple no solo para interfaces sino también para clases. Lo que todos sabemos no es posible para nosotros, los programadores de aplicaciones.
(2) El literal nulo se podría imaginar como una variable definida como:
JVM_global final null_type null = new null_type();
Tenga en cuenta también JLS 3.9 :
A veces se asume, incorrectamente, que una variedad de secuencias de caracteres son palabras clave:
nullno es una palabra clave, sino el literal nulo ( §3.10.7 ).
Sobre null instanceof <any type>
Con JLS 4.10.2 en mente (“el tipo nulo es un subtipo de cada tipo”) null instanceof <any type>debería suponerse que debe evaluarse true, ¿no es así? A primera vista, sí, pero JLS 15.20.2 da la respuesta intuitiva :
[...] el resultado del instanceofoperador es truesi el valor de RelationalExpression no esnull [...]. De lo contrario, el resultado esfalse .
[Énfasis mío.]
Pregúntese qué tiene más sentido (desde el punto de vista de un programador de aplicaciones):
Dar falsey así indicar que una expresión de referencia no es de un tipo que se nos expone, es decir, indicar que no hace referencia a nada útil para nosotros.
o dando true, informándonos así que la expresión evalúa a una referencia especial, la referencia nula , haciendo referencia a un "objeto" no sabemos si existe y cuál es del tipo nulo especial que no tiene nombre, no está expuesto a nosotros, pero a través del literal nulo , ¿es un subtipo de algún tipo que incluya herencia múltiple y debe ignorarse de todos modos? Considere también el ejemplo más práctico:
class Car implements Vehicle {
...
Vehicle car = null;
...
boolean b = car instanceof Car; // True? There's not even an instance
... // which could be of type Car.
Lo que también conduce a:
¿Por qué instanceofno es una forma adecuada de decir algo sobre nullla objetividad de '?
Se llama instanceofno sameorsubtypeof. Eso significa que estamos comparando el tipo de una instancia con un tipo, no con dos tipos. Ahora nullsignifica: “No hay instancia” y si no hay instancia no hay tipo de instancia. Es obvio que se supone que no se debe comparar nada con algo false.
O en un ejemplo "más" del mundo real:
- Tengo una imagen en tamaño real de una manzana ( = tipo de referencia ) en mis manos con »Big Apple« ( = nombre del tipo de referencia ) escrito en ella.
- Hay una mesa ( = montón ) frente a mí.
- Si hay una manzana ( = instancia ) en la mesa, hay un cable ( = referencia ) conectado a ella.
- Sostengo el otro extremo de este cable en mi mano ( = variable de referencia ).
- Trazo la manzana a lo largo del cordón y la comparo con mi imagen ( = instancia de ).
- Si la manzana es del mismo tamaño o más grande que la imagen, se le aplica la escritura "Gran Manzana" ( = verdadero ).
- Si es más pequeño, entonces no ( = falso ).
- Si no hay una manzana sobre la mesa (= no hay instancia ) y, por lo tanto, no existe un cable ( = nulo ), la escritura tampoco se aplica ( = falso ). Porque: ¿ No es una manzana una gran manzana? No, no es.
Como resume Michael: "null es especial" de hecho.