Literales en Java

"Amigo, te envidio. ¡Aprender cosas nuevas es tan maravilloso! Y hoy te espera un tema nuevo e interesante: los literales".

"Aparentemente debería decir que soy el estudiante robot más feliz del planeta, Rishi. Bueno, ¡estoy listo para absorber el nuevo conocimiento!"

"Vamos a hacerlo de inmediato entonces. Los literales son datos específicos escritos directamente en el código de un programa. No estamos hablando de cualquier dato. Solo estamos hablando de tipos primitivos y cadenas.

Por ejemplo, suponga que tiene este código:

int a = 5;
int b = a + 10;
String s = "Sum=" + (a + b);

5
10
"Sum="

"Los literales en este código son el número 5 , el número 10 y la cadena ' Suma = '.

Literales enteros

"En Java, todo, incluidos los literales, tiene un tipo. Todos los literales enteros (enteros) en el código son enteros . El tipo int es el tipo entero estándar de Java".

Conozco este tipo. Lo he usado.

"¿Recuerdas otros tipos de enteros además de int? ¿Algunos que ocupan menos espacio en la memoria?"

"¡Por supuesto! Byte y corto".

"Esos son los indicados. Entonces, si en tu código decides asignar un literal entero a una variable de tipo byte o short, no habrá problemas. Lo principal es que el valor del literal esté dentro del rango de valores que el El compilador de Java es lo suficientemente inteligente como para comprender que a una variable de byte se le puede asignar el literal entero 100.

Ejemplos:

int a = 300;

byte a = 100; 

byte a = 300; 

"¿Qué pasa con el tipo largo ?"

"También podemos escribir literales de este tipo en nuestro código. Para ello, agregue la letra latina 'L' o 'l' al final del entero.

Ejemplos:

long a = 3000000000L; 

long a = 3000000000; 

int a = 3000000000L; 

"¿Te diste cuenta de lo difícil que es leer grandes números de 10 o más dígitos?

"Sí, si no tiene habilitada su robovisión, entonces no quedará claro de inmediato si estamos hablando de 3 mil millones o 30".

"Para hacer que el código sea más legible (¡y esto es importante!), Java permite que se inserten guiones bajos en literales numéricos (no afectan el valor del número).

"El ejemplo anterior se puede reescribir con guiones bajos para que quede un poco más claro:

long a = 3_000_000_000L; 

long a = 3_000_000_000; 

int a = 3_000_000_000L; 

"Esto es mucho más conveniente de leer, ¡aunque una coma en lugar de un guión bajo sería más familiar!"

"Pero no podemos usar comas en literales numéricos porque ya se usan para otro propósito. Por ejemplo, para separar argumentos entre sí al llamar a un método.

Literales de números reales

"Probablemente ya haya adivinado que en su código puede especificar no solo números enteros, sino también literales de coma flotante (números reales)".

"¿Tanto dobles como flotadores?"

"Sí. En realidad, la regla es bastante simple: si un número en el código tiene un punto decimal, entonces el número es un literal de punto flotante. Y no cualquier literal, sino un doble literal. Para crear un literal flotante , debe necesita poner la letra 'F' (o 'f') al final del número .

Ejemplos:

double a = 100.0; 

double a = 100.;

double a = .0;

float a = 100.0f; 

float a = 100.0; 

"Por cierto, puede convertir explícitamente un literal entero en un literal flotante o doble simplemente agregando el sufijo 'F' (para flotante ) o D (para doble ). Ejemplos:

double a = 100D; 

float a = 100F; 

int a = 300D; 

"Los literales de punto flotante pueden usar notación científica : además de la parte firmada del número, también puede especificar una potencia de diez. Ejemplo:

Literales de cadena

"También puede especificar líneas enteras de texto en su código. Para indicarle al compilador que trate una cadena como datos (un literal) y no como parte del código, la cadena completa está entre comillas dobles en ambos lados.

"Si una sola línea de código tiene varias comillas dobles, entonces se dividen en pares. La primera comilla doble indica el comienzo de un literal. La siguiente indica el final del literal. La siguiente marca una vez más el comienzo de un nuevo literal, y el siguiente marca el final del segundo literal, y así sucesivamente.

"Cada uno de esos literales es un String .

Ejemplos

"+"+"+"+"+"+"+"+"+"

""

"2+3"+"-5"

"return"+";"

"Si un literal de cadena es demasiado largo, puede dividirse en varias líneas y pegarse con el 'operador más':

String s = "I hold it true, whate'er befall"
         + "I feel it when I sorrow most;"
         + "'Tis better to have loved and lost"
         + "Than never to have loved at all.";

Literales de caracteres

"¿Qué sucede si necesito un literal que sea un solo carácter en lugar de una cadena? ¿Debería crear una cadena que consista en un solo carácter?"

"No, en ese caso necesitas un literal cuyo tipo sea char. ¿Puedes adivinar cómo se designa el principio y el final de dicho literal?"

"¿Comillas simples?"

"Sí, y dentro de las comillas simples debe haber un carácter y solo un carácter. No puede usar comillas simples vacías.

Ejemplos:

'A'

'@' 

'本' 

'\u1f3a'

"El último ejemplo asigna un carácter Unicode usando una notación especial: primero tenemos el prefijo \u, seguido de 4 caracteres hexadecimales. Aprenderá más sobre esto en las próximas lecciones".