En Java, las variables son contenedores que almacenan datos. Cada variable tiene un tipo, que define qué tipo de datos puede almacenar y cómo se comportan esos datos.

1. ¿Qué es una variable?

Una variable es un espacio en la memoria que tiene:

• Nombre: Identifica la variable.
• Tipo: Determina qué tipo de datos puede almacenar.
• Valor: El dato almacenado en la variable.

Declaración de una variable

La sintaxis básica para declarar una variable es:

Tipo nombre = valor;

Por ejemplo:

int edad = 25;

Aquí:

• int es el tipo de dato.
• edad es el nombre de la variable.
• 25 es el valor inicial.

2. Tipos de datos primitivos

Java tiene 8 tipos de datos primitivos, que se agrupan en 4 categorías principales.

2.1 Tipos numéricos enteros

• byte: Entero de 8 bits. Rango: -128 a 127.

  byte numeroPequeno = 100;

• short: Entero de 16 bits. Rango: -32,768 a 32,767.

  short numeroMedio = 20000;

• int: Entero de 32 bits. Rango: -2,147,483,648 a 2,147,483,647.

  int numeroGrande = 100000;

• long: Entero de 64 bits. Rango: -9,223,372,036,854,775,808 a 9,223,372,036,854,775,807.

  long numeroMuyGrande = 10000000000L; // Nota: se usa 'L' para indicar un long.

2.2 Tipos numéricos decimales

• float: Número en coma flotante de 32 bits. Precisión: ~6-7 dígitos decimales.

  float decimalPequeno = 3.14f; // Nota: se usa 'f' para indicar un float.

• double: Número en coma flotante de 64 bits. Precisión: ~15-16 dígitos decimales.

  double decimalGrande = 3.14159265359;

2.3 Tipo de carácter

• char: Almacena un único carácter Unicode de 16 bits.

  char letra = 'A';
  char simbolo = '\u0041'; // Representación Unicode para 'A'.

2.4 Tipo lógico

• boolean: Almacena un valor lógico: true o false.

  boolean esVerdad = true;
  boolean esFalso = false;

3. Inicialización de variables

Es importante inicializar las variables antes de usarlas. En Java no se permite acceder a una variable sin asignarle un valor inicial. Java, a las variables de tipos primitivos les asigna un valor por defecto:

• Tipos numéricos: 0
• Booleanos: false
• Caracteres: ‘\0’

Sin embargo es muy recomendable inicializar siempre los valores de las variables. Tanto por legibilidad como por prevención de efectos no deseados.

Ejemplo:

int numero;
numero = 10; // Inicialización posterior
System.out.println(numero);
char caracter = 'A'; // Declaramos e inicializamos en la misma línea
System.out.println(caracter);

4. Reglas para nombrar variables

1. El nombre solo puede comenzar con una letra, un signo de dólar ($) o un guion bajo (_). En principio es recomendable utilizar siempre una letra minúscula para empezar una variable. Es un convenio totalmente aceptado y extendido. Empezar por $ o por _ implicaría que la variable tiene un carácter especial.
2. El nombre de la variable no puede contener espacios ni caracteres especiales (excepto $ y _).
3. No puede ser una palabra reservada de Java (como int, class, etc.).
4. Se recomienda usar la terminología camelCase en lugar de snake_case:

   int miVariable;

5. Ejemplo completo

A continuación, un programa que demuestra el uso de los tipos de datos primitivos:

public class TiposDeDatos {
    public static void main(String[] args) {
        // Tipos enteros
        byte miByte = 127;
        short miShort = 32000;
        int miInt = 2147483647;
        long miLong = 9223372036854775807L;

        // Tipos decimales
        float miFloat = 3.14f;
        double miDouble = 3.14159265359;

        // Tipo carácter
        char miChar = 'J';

        // Tipo booleano
        boolean miBoolean = true;

        // Imprimir variables
        System.out.println("byte: " + miByte);
        System.out.println("short: " + miShort);
        System.out.println("int: " + miInt);
        System.out.println("long: " + miLong);
        System.out.println("float: " + miFloat);
        System.out.println("double: " + miDouble);
        System.out.println("char: " + miChar);
        System.out.println("boolean: " + miBoolean);
    }
}

Salida esperada:

byte: 127
short: 32000
int: 2147483647
long: 9223372036854775807
float: 3.14
double: 3.14159265359
char: J
boolean: true

6. Conversiones de tipos

A menudo es necesario convertir valores de un tipo a otro para realizar ciertas operaciones. Este proceso se llama conversión de tipos o casting.

Existen dos tipos principales de conversión de tipos en Java:

a) Conversión Implícita (Widening Casting)

• Ocurre automáticamente cuando un valor de un tipo más pequeño se asigna a una variable de un tipo más grande.
• Ejemplo: De int a double.
• Riesgo: No hay pérdida de datos.

b) Conversión Explícita (Narrowing Casting)

• Necesita ser especificada manualmente por el programador.
• Se realiza cuando se asigna un valor de un tipo más grande a una variable de un tipo más pequeño.
• Ejemplo: De double a int.
• Riesgo: Puede haber pérdida de datos.

6.1. Conversión Implícita

Java realiza esta conversión automáticamente si no hay riesgo de pérdida de datos. La jerarquía de tipos primitivos en Java (de menor a mayor) es:

byte -> short -> int -> long -> float -> double

Ejemplo:

public class ConversionImplicita {
    public static void main(String[] args) {
        int numeroEntero = 42;
        double numeroDecimal = numeroEntero; // Conversión implícita

        System.out.println("Valor original (int): " + numeroEntero);
        System.out.println("Valor convertido (double): " + numeroDecimal);
    }
}

Salida esperada:

Valor original (int): 42
Valor convertido (double): 42.0

Notas importantes:

• No es necesario usar ningún operador de casting.
• La precisión no se pierde porque double puede representar todos los valores de int.

6.2. Conversión Explícita

Cuando se necesita convertir un tipo más grande a uno más pequeño, el programador debe usar el operador de casting ((tipo)).

Ejemplo:

public class ConversionExplicita {
    public static void main(String[] args) {
        double numeroDecimal = 42.7;
        int numeroEntero = (int) numeroDecimal; // Conversión explícita

        System.out.println("Valor original (double): " + numeroDecimal);
        System.out.println("Valor convertido (int): " + numeroEntero);
    }
}

Salida esperada:

Valor original (double): 42.7
Valor convertido (int): 42

Notas importantes:

• Se pierde la parte decimal, ya que int solo almacena números enteros.
• El operador (int) indica que estamos forzando la conversión.

6.3. Ejemplo Combinado: Implicita y Explícita

public class ConversionCombinada {
    public static void main(String[] args) {
        int numeroEntero = 10;
        double numeroDecimal = numeroEntero; // Conversión implícita

        System.out.println("Conversión implícita: " + numeroDecimal);

        double otroDecimal = 9.99;
        int otroEntero = (int) otroDecimal; // Conversión explícita

        System.out.println("Conversión explícita: " + otroEntero);
    }
}

Salida esperada:

Conversión implícita: 10.0
Conversión explícita: 9

6.4. Conversión entre char y tipos numéricos

En Java, los caracteres (char) se pueden convertir a valores numéricos según su código Unicode.

Ejemplo:

public class ConversionChar {
    public static void main(String[] args) {
        char letra = 'A';
        int codigoAscii = letra; // Conversión implícita

        System.out.println("El código ASCII de 'A' es: " + codigoAscii);

        int numero = 66;
        char letraConvertida = (char) numero; // Conversión explícita

        System.out.println("El carácter correspondiente a 66 es: " + letraConvertida);
    }
}

Salida esperada:

El código ASCII de 'A' es: 65
El carácter correspondiente a 66 es: B

6.5. Errores comunes

• Pérdida de datos: Al convertir de un tipo más grande a uno más pequeño.
• Desbordamiento: Cuando el valor convertido excede el rango del tipo de destino.

Ejemplo de pérdida de datos:

public class PerdidaDatos {
    public static void main(String[] args) {
        long numeroGrande = 123456789012345L;
        int numeroPequeno = (int) numeroGrande;

        System.out.println("Valor original (long): " + numeroGrande);
        System.out.println("Valor convertido (int): " + numeroPequeno);
    }
}

Salida esperada:

Valor original (long): 123456789012345
Valor convertido (int): 1942903641

Notas:

• El valor se corrompe porque int no puede almacenar números tan grandes como long.

7. Resumen

• Java tiene 8 tipos de datos primitivos que cubren números enteros, decimales, caracteres y valores lógicos.
• Las variables deben declararse y, preferiblemente, inicializarse antes de usarse.
• Seguir las reglas de nomenclatura ayuda a escribir código claro y legible.
• La conversión implícita es automática y segura.
• La conversión explícita requiere el operador de casting y puede ocasionar pérdida de datos.
• Practicar ambos tipos de conversión te ayudará a entender cómo manipular diferentes tipos de datos en Java.

Reflexión:

Conocer los tipos de datos primitivos y su uso es esencial para manejar la información en cualquier programa. A medida que avances, aprenderás a combinarlos para resolver problemas más complejos. Por otro lado, la conversión de tipos es una herramienta poderosa. Sin embargo debe usarse con cuidado para evitar errores como pérdida de precisión o desbordamientos.