Introducción

En el mundo de la programación, una variable es un contenedor de datos que actúa como una ubicación en la memoria del computador, la cual puede almacenar un valor que puede cambiar durante la ejecución del programa. Las variables se utilizan para representar información que debe ser procesada, almacenada y manipulada, como números, textos o estados lógicos.

Por otro lado, un tipo de dato define la naturaleza del valor que una variable puede almacenar y especifica las operaciones que se pueden realizar sobre dicho valor. En Java, un lenguaje fuertemente tipado, cada variable tiene un tipo de dato específico (por ejemplo, int, double o String), lo que garantiza que se utilicen de manera coherente durante la ejecución de la aplicación.

1. Las variables en el lenguaje Java 21

En Java, una variable es un contenedor de datos con un tipo específico y un nombre identificador. Aunque Java ha sido históricamente un lenguaje fuertemente tipado, desde Java 10 se introdujo la palabra clave var para permitir la inferencia de tipos en variables locales sin perder la seguridad del tipado. Esto ayuda a reducir la verbosidad cuando el tipo es evidente a partir del valor asignado.

En Java, una variable se declara indicando el tipo de dato y un nombre para la variable. La sintaxis básica es tipo nombreDeVariable; , vea un ejemplo con declaración explícita e inferencia de tipos:

// Declaración explícita
int numero = 10;

// Uso de inferencia de tipos (disponible para variables locales)
var mensaje = "Hola, Java 21!";

La flexibilidad que ofrece var sirve para simplificar el código, siempre que se utilice con criterio para mantener la claridad.

2. Las variables primitivas en Java

Java define ocho tipos de datos primitivos: byte, short, int, long, float, double, boolean y char. Estos tipos almacenan valores simples y se asignan en la pila de memoria, lo que permite un manejo eficiente en términos de rendimiento. Cada uno de estos tipos posee un rango de valores específico y se deben elegir según las necesidades de precisión y consumo de memoria de la aplicación.

Ejemplo de declaración y uso de variables primitivas:

byte b = 100;         // 8 bits
short s = 30000;      // 16 bits
int i = 100000;       // 32 bits
long l = 10000000000L; // 64 bits (nota la 'L' al final)

// Variables reales
float f = 3.14F;      // 32 bits (se utiliza 'F')
double d = 3.141592653589793; // 64 bits

Cada decisión en la elección del tipo influye en el consumo de memoria y en la eficiencia de los cálculos.

3. Los datos simples ordinales o enteros en el lenguaje Java

Los datos enteros representan números sin parte decimal, utilizados para contar, indexar y realizar operaciones aritméticas básicas. Los tipos enteros en Java son:

• byte: 8 bits (rango de -128 a 127)
• short: 16 bits (rango de -32,768 a 32,767)
• int: 32 bits (el tipo entero más común) (rango de -2.147.483.648 y 2.147.483.647)
• long: 64 bits (para números de gran magnitud) (rango de -9,223,372,036,854,775,808 y 9,223,372,036,854,775,807)

Ejemplo:

byte edad = 25;
short cantidadEstudiantes = 320;
int numeroDeUsuarios = 1_000_000;
long distanciaEnMetros = 9_461_000_000L;

Utilizar el tipo adecuado evita el uso innecesario de memoria, lo cual es especialmente importante en aplicaciones de recursos limitados.

4. Los datos simples reales en el lenguaje Java

Para representar números con parte decimal, Java dispone principalmente de dos tipos:

• float: Precisión simple (32 bits). Se debe utilizar un sufijo F (o f) en el literal.
• double: Precisión doble (64 bits); es el tipo predeterminado para operaciones con números reales.

Ejemplo:

float temperatura = 36.6F;
double distancia = 12345.6789;

Es vital tener en cuenta que la representación en coma flotante puede introducir pequeñas imprecisiones en cálculos matemáticos.

5. Las variables boolean y char

Boolean

El tipo boolean almacena valores lógicos, y solo puede contener true o false. Se utiliza principalmente en expresiones condicionales y estructuras de control.

boolean esValido = true;
if (esValido) {
    System.out.println("La condición es verdadera.");
}

Char

El tipo char representa un único carácter Unicode y se declara usando comillas simples.

char letra = 'A';
char simbolo = '€';

Estos tipos son fundamentales para controlar la lógica del programa y la representación de caracteres.

6. Nombres de las variables

Elegir nombres significativos y correctos para las variables es crucial para la claridad y mantenibilidad del código. Las reglas básicas son:

• Deben iniciar con una letra, un guion bajo _ o un signo de dolar $ (aunque este último raramente se usa).
• Pueden incluir dígitos, pero no deben comenzar con ellos.
• Son case-sensitive (por ejemplo, edad y Edad se consideran diferentes).
• Se recomienda usar la convención camelCase para nombres compuestos (ejemplo: numeroDeEstudiantes).

Ejemplo:

int numeroDeEstudiantes = 30;
double precioTotal = 99.99;
boolean esActivo = false;

7. Literales numéricos

Los literales son representaciones directas de números en el código. En Java se pueden emplear diferentes bases numéricas:

Decimal:

int decimal = 50;

Hexadecimal: Se usa el prefijo 0x o 0X.

int hexadecimal = 0x1A; // 26 en decimal

Binario: Desde Java 7 se usa el prefijo 0b o 0B.

int binario = 0b1101; // 13 en decimal

Octal: Representado con un 0 inicial.

int octal = 075; // 61 en decimal

Estas diversas representaciones son útiles cuando se realizan operaciones a nivel de bits o se desea mejorar la legibilidad de ciertos valores.

8. Ámbito de existencia de las variables

El ámbito (scope) determina la visibilidad y duración de una variable dentro del programa. En Java se distinguen tres tipos principales:

Variables locales: Declaradas dentro de un método, constructor o bloque. Solo existen dentro de ese bloque.

public void metodo() {
    int contador = 0; // Variable local
}

Variables de instancia: Son los atributos no estáticos de una clase; cada objeto tiene su propia copia.

public class Estudiante {
    private String nombre; // Variable de instancia
    
    public Estudiante(String nombre) {
        this.nombre = nombre;
    }
}

Variables de clase (estáticas): Declaradas con el modificador static, pertenecen a la clase y son compartidas por todas las instancias.

public class Configuracion {
    public static final String VERSION = "1.0.0"; // Variable de clase
    
    public static void mostrarVersion() {
        System.out.println("Versión: " + VERSION);
    }
}

Comprender el ámbito es esencial para evitar errores y gestionar apropiadamente la memoria.

9. La clase String

Aunque se utilicen para representar texto, las variables de tipo String en Java son objetos de la clase String, no tipos primitivos. Una característica fundamental es que las cadenas son inmutables: una vez creadas, su valor no puede modificarse. Esto mejora la seguridad y permite el uso eficiente del String pool.

En Java, una variable String es una variable que almacena una secuencia de caracteres y, a diferencia de los tipos primitivos, es un objeto de la clase String. Esto implica lo siguiente:

1. Inmutabilidad: Una vez creada una cadena, su contenido no se puede alterar. Si realizas una operación que «modifica» la cadena, en realidad se crea un nuevo objeto String.
2. Métodos útiles: La clase String viene equipada con numerosos métodos que facilitan la manipulación del texto, como length(), toUpperCase(), substring(), replace(), entre otros.
3. Literalidad: Las cadenas se definen encerrando el texto entre comillas dobles.
4. Pool de Cadenas: Java gestiona un «pool» de cadenas, lo que permite reutilizar instancias de String cuando se usan literales idénticos, ahorrando memoria y aumentando la eficiencia.

String saludo = "Hola, mundo!";

En resumen, las variables String son esenciales para el manejo de textos en Java y su naturaleza inmutable junto con los métodos disponibles las convierte en una herramienta poderosa para trabajar con datos textuales.

public class EjemploString {
    public static void main(String[] args) {
        String saludo = "Hola";
        // Concatenación de cadenas
        saludo = saludo + ", mundo!";
        System.out.println(saludo); // Imprime "Hola, mundo!"

        // Uso de métodos de String
        System.out.println("Longitud: " + saludo.length());
        System.out.println("En mayúsculas: " + saludo.toUpperCase());
    }
}

10 ¿Qué es una variable constante?

Una variable constante es un identificador al que se le asigna un valor que no puede ser modificado una vez establecido. En Java, la forma de definir una constante es mediante el uso de la palabra clave final. Al declarar una variable como final, se garantiza que su valor permanece inmutable a lo largo de la ejecución del programa, lo que ayuda a evitar modificaciones accidentales y a dar claridad al propósito de ciertos valores fijos en el código.

Por convención, el nombre de las constantes se escribe completamente en mayúsculas, utilizando guiones bajos para separar las palabras. Esto permite identificarlas fácilmente en el código y distinguirlas de las variables cuyo valor puede cambiar.

Ejemplo de variable constante:

final double PI = 3.14159;
final int MESES_EN_UN_AÑO = 12;

En estos ejemplos, PI y MESES_EN_UN_AÑO son constantes. Una vez que se les asigna el valor inicial (3.14159 y 12, respectivamente), dicho valor no podrá ser modificado en cualquier parte del programa. Esto las hace ideales para representar valores universales o fijos que no deben cambiar, tales como parámetros matemáticos, configuraciones o cualquier dato de uso global en la aplicación.

11. Las variables var en Java

La palabra clave var, introducida en Java 10 y presente en Java 21, permite que el compilador infiera el tipo de las variables locales según el valor asignado. Esto reduce la redundancia en la declaración, siempre y cuando el tipo sea obvio para quien lee el código.

Ventajas y Desventajas de Usar var

Ventajas:

• Reduce la verbosidad: No es necesario repetir el tipo cuando este se deduce del valor asignado.
• Mejora la mantenibilidad: Facilita la refactorización en expresiones complejas y evita redundancias.
• Código más limpio: Especialmente útil cuando se trabajan con tipos largos o genéricos.

Desventajas:

• Pérdida de claridad: En casos donde el tipo no es evidente, puede dificultar la comprensión del código.
• Limitado a variables locales: No se puede usar en atributos de clase ni en parámetros de métodos.
• Ambigüedad potencial: Su uso indiscriminado puede llevar a errores si el tipo inferido no es el esperado.

Ejemplo de uso:

var numero = 100;            // Se infiere como int
var mensaje = "Hola, Java";   // Se infiere como String

El uso adecuado de var facilita la escritura del código, sin perder la seguridad en el momento de compilación.

12. Tabla de tipos de datos en Java con sus características

A continuación se presenta una tabla resumen de los principales tipos de datos en Java:

\* El tamaño de un boolean varía según la implementación de la JVM.

13. Ejemplos prácticos de uso de cada tipo de dato en Java

A continuación se muestran ejemplos de cómo declarar e imprimir variables de cada tipo:

byte

byte edad = 25;
System.out.println("Edad (byte): " + edad);

short

short cantidadEstudiantes = 320;
System.out.println("Estudiantes (short): " + cantidadEstudiantes);

int

int numeroDeUsuarios = 1_000_000;
System.out.println("Usuarios (int): " + numeroDeUsuarios);

long

long distancia = 9_461_000_000L;
System.out.println("Distancia (long): " + distancia);

float

float temperatura = 36.6F;
System.out.println("Temperatura (float): " + temperatura);

double

double pi = 3.141592653589793;
System.out.println("Valor de pi (double): " + pi);

boolean

boolean esValido = true;
System.out.println("Es válido (boolean): " + esValido);

char

char letra = 'A';
System.out.println("Letra (char): " + letra);

String

String saludo = "Hola, mundo!";
System.out.println("Saludo (String): " + saludo);

var (inferido)

var mensaje = "Inferido como String";
System.out.println("Mensaje (var): " + mensaje);

14. Programa completo en Java con todos los tipos de datos

El siguiente es un programa de demostración que declara variables de todos los tipos mencionados e imprime sus valores:

public class TiposDeDatos {
    public static void main(String[] args) {
        // Declaración de variables de los tipos primitivos
        byte b = 100;                       // 8 bits
        short s = 30000;                    // 16 bits
        int i = 100000;                     // 32 bits
        long l = 10000000000L;              // 64 bits (se utiliza sufijo L)
        float f = 3.14F;                    // 32 bits (se utiliza sufijo F)
        double d = 3.141592653589793;       // 64 bits
        boolean bool = true;                // Valor lógico, true o false
        char c = 'A';                       // Un solo carácter
        
        // Declaración de variables de referencia
        String str = "Hola, mundo!";        // Cadena de caracteres
        
        // Uso de var para inferir el tipo en variables locales
        var varInt = 123;                   // Se infiere como int
        var varString = "Inferido como String"; // Se infiere como String
        var varDouble = 99.99;              // Se infiere como double
        
        // Impresión de cada variable sin utilizar ningún método de la clase String
        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);
        System.out.println("boolean: " + bool);
        System.out.println("char: " + c);
        System.out.println("String: " + str);
        System.out.println("var (int): " + varInt);
        System.out.println("var (String): " + varString);
        System.out.println("var (double): " + varDouble);
    }
}

Explicación:

• Se declaran variables de cada tipo (primitivo y de referencia).
• Se utilizan variables con var para demostrar la inferencia de tipos.
• Se imprime el valor de cada variable.

Creamos un archivo llamado TiposDeDatos.java , compilamos y ejecutamos con javac y java:

$ javac TiposDeDatos.java
// Sin errores de compilación.
// Compilamos...
$ java TiposDeDatos
// Resultado por consola:
byte: 100
short: 30000
int: 100000
long: 10000000000
float: 3.14
double: 3.141592653589793
boolean: true
char: A
String: Hola, mundo!
var (int): 123
var (String): Inferido como String
var (double): 99.99

15. Distintas formas de definir una variable en Java

Java permite declarar variables de diversas maneras según el contexto y la necesidad:

15.1. Declaración e Inicialización en una Única Instrucción

La forma más común, donde se declara la variable y se le asigna un valor de inmediato.

int numero = 10;
String nombre = "Soraya";
double precio = 99.99;

15.2. Declaración sin Inicialización (Asignación Posterior)

Se declara la variable sin asignarle inmediatamente un valor, para inicializarla posteriormente. Es fundamental asignar un valor antes de usarla, especialmente con variables locales.

int contador;
contador = 5;

String mensaje;
mensaje = "Buenas tardes";

15.3. Declaración Múltiple en una Única Línea

Se pueden declarar varias variables del mismo tipo en una sola línea, separadas por comas.

int a = 1, b = 2, c = 3;

15.4. Declaración en Bloques y en Bucles

Las variables se pueden declarar dentro de bloques o bucles, limitando su alcance al bloque en cuestión.

for (int i = 0; i < 10; i++) {
    System.out.println("Valor de i: " + i);
}

15.5. Variables de Instancia y de Clase

Variables de Instancia: Declaradas en el cuerpo de la clase pero fuera de los métodos. Cada objeto tiene su propia copia.

public class Persona {
    private String nombre; // Variable de instancia
    
    public Persona(String nombre) {
        this.nombre = nombre;
    }
}

Variables de Clase (Estáticas): Declaradas con la palabra clave static, pertenecen a la clase y son compartidas por todas las instancias.

public class Configuracion {
    public static final String APP = "MiAplicacion";
}

15.6. Declaración de Variables Inmutables (Constantes)

Una variable constante es aquella a la que se le asigna un valor único que no puede cambiar durante la ejecución del programa.

• Se utiliza la palabra clave final para declararlas.
• Por convención, sus nombres se escriben en mayúsculas y con guiones bajos para separar las palabras.

final double PI = 3.14159;
final int MESES_EN_UN_AÑO = 12;

15.7. Declaración con Inferencia de Tipos Usando var

Con var el compilador deduce el tipo de la variable según el valor asignado.

var edad = 25;                // Se infiere como int
var mensaje = "Hola, Mundo!";   // Se infiere como String

Cada método de declaración tiene su uso según el contexto, y la elección correcta contribuye a la claridad, escalabilidad y mantenibilidad del código.

16. Conversión entre tipos de datos primitivos en Java

En Java, existen dos formas principales de convertir datos de un tipo a otro cuando trabajamos con tipos primitivos:

1. Conversión implícita (automática)
2. Conversión explícita (manual o «casting»)

La elección entre estos métodos depende del tamaño y la precisión del tipo de dato al que queremos convertir. A continuación, se explican ambos conceptos con ejemplos fáciles de entender.

16.1. Conversión implícita (automática)

La conversión implícita ocurre cuando el compilador de Java convierte automáticamente un tipo de dato más pequeño a uno más grande. Esto sucede porque el tipo más grande tiene suficiente espacio para almacenar el valor del tipo más pequeño sin perder información.

Los tipos de datos en Java tienen un orden de tamaño, desde los más pequeños hasta los más grandes: byte → short → int → long → float → double

Ejemplo de conversión implícita:

public class ConversionImplicita {
    public static void main(String[] args) {
        int numeroEntero = 100;   // Tipo int
        double numeroDecimal = numeroEntero; // Conversión automática a double

        System.out.println("Número entero (int): " + numeroEntero);
        System.out.println("Número decimal (double): " + numeroDecimal); 
    }
}

Explicación: El valor del tipo int (100) se convierte automáticamente a double, sin necesidad de realizar ningún «casting». No hay pérdida de datos porque double tiene mayor precisión y tamaño que int.

Otro ejemplo con float y double:

float numeroFlotante = 3.14F;    // Tipo float
double numeroDoble = numeroFlotante; // Conversión automática a double

System.out.println("Número flotante (float): " + numeroFlotante);
System.out.println("Número doble (double): " + numeroDoble);

De nuevo, la conversión ocurre sin problemas porque double tiene más capacidad de almacenamiento que float.

16.2. Conversión explícita (manual o «casting»)

La conversión explícita es cuando el programador le indica al compilador que convierta un tipo más grande en uno más pequeño. Esto puede ocasionar pérdida de datos si la información del tipo más grande no cabe en el tipo más pequeño.

Para realizar esta conversión, se usa el casting, que consiste en colocar el tipo de dato entre paréntesis antes de la variable que queremos convertir.

Ejemplo de conversión explícita:

public class ConversionExplicita {
    public static void main(String[] args) {
        double numeroDecimal = 9.99;    // Tipo double
        int numeroEntero = (int) numeroDecimal; // Conversión manual a int

        System.out.println("Número decimal (double): " + numeroDecimal);
        System.out.println("Número entero (int después de casting): " + numeroEntero); 
    }
}

Explicación: El número 9.99 se almacena como double, pero al convertirlo a int, se pierde la parte decimal y solo queda 9. Este es un ejemplo clásico de pérdida de precisión al hacer un casting de double a int.

Otro ejemplo con long y short:

long numeroGrande = 100000L; // Tipo long
short numeroPequeño = (short) numeroGrande; // Conversión explícita

System.out.println("Número grande (long): " + numeroGrande);
System.out.println("Número pequeño (short después de casting): " + numeroPequeño);

Aquí la conversión manual de long a short funciona, pero si el número long hubiera sido mayor que el rango de short (-32,768 a 32,767), el resultado sería incorrecto debido al desbordamiento de datos (overflow).

16.3 Resumen de conversiones

Consejos sobre conversiones:

• Usa conversiones implícitas cuando Java pueda manejar el cambio sin problemas.
• Usa casting explícito solo cuando estés seguro de que no habrá pérdida significativa de datos.
• Ten cuidado con la conversión de double a int, ya que elimina la parte decimal.
• Comprueba siempre el rango de valores antes de convertir tipos más grandes a más pequeños, para evitar errores o desbordamientos.

Estos conceptos de conversión son fundamentales en Java, ya que en muchas ocasiones es necesario convertir datos entre distintos tipos según la lógica del programa.

Resumen

En este recorrido se han abordado los aspectos fundamentales del manejo de variables y tipos de datos en Java 21:

• Variables en Java: Son contenedores de datos con un tipo definido y un nombre. La introducción de var permite que el compilador infiera el tipo en variables locales, reduciendo la verbosidad sin comprometer la seguridad en tiempo de compilación.
• Tipos Primitivos y Datos Simples: Se incluyen byte, short, int, long, float, double, boolean y char, cada uno optimizado para distintos fines (almacenamiento, cálculos y representación).
• Datos Enteros y Reales: Se utilizan para almacenar números sin y con decimales, respectivamente, esenciales en toda aplicación.
• Variables Boolean y Char: Manejan valores lógicos y caracteres únicos.
• Nomenclatura y Literales: La correcta elección de nombres y la representación de literales son vitales para la legibilidad del código.
• Ámbito de las Variables: Comprender el alcance (local, de instancia o de clase) es indispensable para evitar errores.
• La Clase String: Se usa para manejar secuencias de caracteres de forma inmutable.
• Uso de var: Brinda flexibilidad mediante la inferencia de tipos, con ventajas y algunas limitaciones.
• Declaración de Constantes: Mediante final se definen variables constantes, cuyo valor no cambia durante la ejecución, aportando estabilidad y claridad al programa.
• Tabla Comparativa y Ejemplos Prácticos: Se resumen las características de cada tipo y se ofrecen ejemplos concretos, culminando con un programa completo.
• Formas de Declarar Variables: Se exploran diversos métodos (declaración inmediata, múltiples, en bucles, variables de instancia/clase, constantes y uso de var) para adecuarse a diferentes escenarios de programación.

Dominar estos conceptos es fundamental para escribir código eficiente, legible y mantenible, sirviendo de base para el desarrollo de aplicaciones robustas y escalables en Java.