Java desde cero: variables, tipos primitivos, clases envoltorio y conversiones

En esta lección aprenderás a declarar variables en Java, comprender los tipos de dato básicos (primitivos), utilizar sus clases envoltorio para convertir valores a texto y desde texto, y a imprimir resultados en pantalla. Es un recorrido paso a paso, sin dar nada por sabido.

Introducción y motivación

Todo programa manipula datos: edades, estaturas, nombres, respuestas de sí/no y números escritos como texto. Para guardarlos necesitaremos variables, para operarlos necesitaremos tipos adecuados, y para mostrarlos o leerlos necesitaremos convertir entre números y cadenas de texto.

Trabajaremos con un ejemplo concreto que declara variables de varios tipos, las convierte a String (texto), y muestra los resultados en la consola.

Mapa conceptual mínimo

• Programa: conjunto de instrucciones. En Java vive dentro de clases.
• Clase: plantilla que agrupa código. Aquí usaremos una clase llamada Main.
• Método main: punto de entrada que se ejecuta al iniciar el programa: public static void main(String[] args).
• Variable: nombre que guarda un valor en memoria. Se declara indicando un tipo (p. ej., int edad;).
• Tipo primitivo: tipo básico y eficiente: int, double, boolean, char, entre otros.
• Tipo por referencia: objetos como String (texto) o clases envoltorio (Integer, Double, etc.).
• Literal: valor escrito literalmente: 20, 1.75, true, 'A', "Ana".
• Clases envoltorio: clases que “envuelven” un primitivo y ofrecen utilidades: Integer, Double, Boolean, Character.
• Conversión a texto: Integer.toString(20) produce "20".
• Parseo desde texto: Integer.parseInt("123") produce el número 123.
• Salida por consola: System.out.println(...) imprime una línea.

El programa que estudiaremos

public class Main {
public static void main(String[] args) {
    // declare y asigne las variables:
    // edad
    int edad = 20;
    // estatura
    double estatura = 1.75;
    // gustaProgrammar
    boolean gustaProgrammar = true;
    // inicial
    char inicial = 'A';
    // nombre
    String nombre = "Ana López";

    String edadComoTexto;
    String estaturaComoTexto;
    String gustoComoTexto;
    int numeroConvertido;

    // Métodos de clases envoltorio
    // convierta edad y estatura a String
    edadComoTexto = Integer.toString(edad);
    estaturaComoTexto = Double.toString(estatura);

    // convierta gustaProgrammar a String
    gustoComoTexto = Boolean.toString(gustaProgrammar);

    // convierta "123" a un int numeroConvertido
    numeroConvertido = Integer.parseInt("123");

    // Imprimir todo
    System.out.println("Nombre: " + nombre);
    System.out.println("Inicial: " + inicial);
    System.out.println("Edad: " + edad + " (" + edadComoTexto + ")");
    System.out.println("Estatura: " + estatura + " (" + estaturaComoTexto + ")");
    System.out.println("¿Te gusta programar?: " + gustaProgrammar + " (" + gustoComoTexto + ")");
    System.out.println("Número convertido desde String: " + numeroConvertido);
}
```

}

Observación: en Java los decimales usan punto (1.75), el carácter usa comillas simples ('A'), el texto usa comillas dobles ("..."), y los booleanos son true o false. La variable gustaProgrammar está escrita con doble “m”; por convención de estilo se prefiere gustaProgramar en lowerCamelCase, pero el código funciona.

Definiciones esenciales

Tabla rápida: primitivos ↔ envoltorios

Teorema central: “Ir y volver” entre número y texto

Heurística → Formal (cómo pensar y cómo escribir)

Análisis preliminar

Cuando necesites mostrar un dato no textual, conviértelo a String. Cuando recibas un número como texto (por ejemplo, de un formulario), parsea ese texto al tipo numérico correcto. Si aparece un error de formato, revisa que la cadena contenga solo dígitos y, para decimales, el punto ..

Demostración formal (patrón de uso correcto)

1. Declarar y asignar: int edad = 20; (declaración + asignación).
2. Convertir a texto: String s = Integer.toString(edad);.
3. Concatenar para imprimir: si una parte es String, el operador + concatena: "Edad: " + edad.
4. Parsear desde texto: int n = Integer.parseInt("123");. Si el texto no es válido, se lanza NumberFormatException.

Recetas de procedimiento

1. Elige el tipo según el dato: int (enteros), double (decimales), boolean (verdadero/falso), char (un carácter), String (texto).
2. Declara y asigna: tipo nombre = valor;.
3. Convierte a texto con TipoEnvoltorio.toString(valor) o String.valueOf(valor).
4. Desde texto a número con TipoEnvoltorio.parseXxx(cadena) (p. ej., Integer.parseInt, Double.parseDouble).
5. Imprime con System.out.println(...); concatena partes con +.

Ejemplos escalonados

Cómo ejecutar (rápido)

1. Guarda el código en un archivo llamado Main.java (el nombre debe coincidir con la clase pública).
2. Compila:

   javac Main.java

3. Ejecuta:

   java Main

4. Verás la salida en la consola.

Errores frecuentes y cómo evitarlos

• Coma en decimales (1,75) → en Java usa 1.75.
• Comillas equivocadas: char usa 'A'; String usa "A".
• Texto inválido al parsear: Integer.parseInt("12a") lanza NumberFormatException. Valida la cadena antes.
• Nombre de archivo/clase: si la clase pública es Main, el archivo debe ser Main.java.
• Signos y espacios: '-' solo al inicio de enteros negativos; no se permiten espacios en el texto a parsear.

Ejercicios propuestos

1. Declara int anio = 2025; y guarda su versión en texto en String anioTxt. Imprime ambos en una línea.
2. Convierte "3.14" a double y multiplícalo por 2. Imprime el resultado.
3. Declara boolean activo = false; conviértelo a texto, e imprime: "¿Activo? " seguido del valor y su versión en texto.
4. Toma String codigo = "A7"; e imprime solo su primer carácter usando codigo.charAt(0).
5. ¿Qué imprime System.out.println("Edad: " + 18 + 2);? ¿Y System.out.println("Edad: " + (18 + 2));?

Soluciones

Conclusión

Aprendiste a declarar variables, elegir tipos primitivos, usar clases envoltorio para convertir datos a texto y desde texto, y a imprimir resultados. El patrón clave es: “dato → toString → texto” y “texto válido → parseXxx → dato”, con la identidad del Teorema (1) como garantía conceptual. Este bloque de fundamentos se conecta naturalmente con entrada/salida de usuario, validación de datos y estructuras de control (condicionales y bucles) que verás a continuación.