Aprende Java en 10 minutos

9 July 2025 — Lenguaje De Programación

Java es un lenguaje de programación de alto nivel y orientado a objetos conocido por su principio de “escribir una vez, ejecutar en cualquier lugar”. Este tutorial cubre las características de Java 21+ y te ayuda a aprender rápidamente los fundamentos de Java.

1. Escribiendo tu primer programa Java

Los programas Java se organizan en clases. Comencemos con un programa simple. Crea un archivo llamado HelloWorld.java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("¡Hola, Mundo!");
    }
}

Compila y ejecuta el programa:

javac HelloWorld.java
java HelloWorld

La salida será:

¡Hola, Mundo!

Este programa simple demuestra la estructura básica de Java. Cada programa Java debe tener al menos una clase, y el método main es el punto de entrada.

2. Sintaxis básica

La sintaxis de Java es estructurada y sigue reglas específicas:

// Este es un comentario de una línea
/* Este es un 
   comentario de múltiples líneas */

public class BasicSyntax {
    public static void main(String[] args) {
        System.out.println("¡Hola, Java!");
    }
}

Reglas básicas de sintaxis en Java:

Sensible a mayúsculas: Java distingue entre mayúsculas y minúsculas. Variable y variable son diferentes.
Nombres de clase: Deben comenzar con una letra mayúscula y seguir la convención CamelCase.
Nombres de método: Deben comenzar con una letra minúscula y seguir la convención camelCase.
Punto y coma: Cada declaración debe terminar con un punto y coma ;.
Llaves: Los bloques de código se definen usando llaves {}.
Comentarios: Los comentarios de una línea usan //, los comentarios de múltiples líneas usan /* */.

3. Variables y tipos de datos

Java es un lenguaje de tipado estático, lo que significa que debes declarar los tipos de variables explícitamente.

Reglas para nombrar variables:

Debe comenzar con una letra, guión bajo _ o símbolo de dólar $.
Puede contener letras, dígitos, guiones bajos y símbolos de dólar.
No puede ser una palabra clave de Java.
Debe seguir la convención camelCase.

Tipos de datos primitivos de Java:

byte: Entero con signo de 8 bits (-128 a 127)
short: Entero con signo de 16 bits (-32,768 a 32,767)
int: Entero con signo de 32 bits (-2^31 a 2^31-1)
long: Entero con signo de 64 bits (-2^63 a 2^63-1)
float: Punto flotante de 32 bits
double: Punto flotante de 64 bits
boolean: verdadero o falso
char: Carácter Unicode de 16 bits

public class DataTypes {
    public static void main(String[] args) {
        // Tipos enteros
        byte edad = 25;
        short año = 2024;
        int población = 1000000;
        long distancia = 93000000L; // Sufijo L para long
        
        // Tipos de punto flotante
        float temperatura = 36.5f; // Sufijo f para float
        double pi = 3.14159265359;
        
        // Tipos booleano y carácter
        boolean estaActivo = true;
        char calificación = 'A';
        
        // Cadena (tipo de referencia)
        String nombre = "Alicia";
        
        System.out.println("Nombre: " + nombre + ", Edad: " + edad);
    }
}

3.1 Operaciones con cadenas

Las cadenas en Java son objetos, no tipos primitivos:

public class StringExample {
    public static void main(String[] args) {
        String texto = "Programación Java";
        
        System.out.println("Longitud: " + texto.length());
        System.out.println("Mayúsculas: " + texto.toUpperCase());
        System.out.println("Minúsculas: " + texto.toLowerCase());
        System.out.println("Carácter en el índice 0: " + texto.charAt(0));
        System.out.println("Subcadena: " + texto.substring(0, 4));
        System.out.println("Contiene 'Java': " + texto.contains("Java"));
        
        // Concatenación de cadenas
        String saludo = "¡Hola, " + "Mundo!";
        System.out.println(saludo);
        
        // Formato de cadenas
        String formateado = String.format("Pi es aproximadamente %.2f", 3.14159);
        System.out.println(formateado);
    }
}

4. Arreglos y colecciones

4.1 Arreglos

Los arreglos almacenan múltiples valores del mismo tipo:

public class ArrayExample {
    public static void main(String[] args) {
        // Declaración e inicialización de arreglo
        int[] números = {1, 2, 3, 4, 5};
        String[] frutas = new String[3];
        frutas[0] = "manzana";
        frutas[1] = "plátano";
        frutas[2] = "naranja";
        
        // Acceso a elementos del arreglo
        System.out.println("Primer número: " + números[0]);
        System.out.println("Longitud del arreglo: " + números.length);
        
        // Iteración a través de arreglos
        for (int i = 0; i < números.length; i++) {
            System.out.println("Número " + i + ": " + números[i]);
        }
        
        // Bucle for mejorado (for-each)
        for (String fruta : frutas) {
            System.out.println("Fruta: " + fruta);
        }
        
        // Arreglos multidimensionales
        int[][] matriz = {{1, 2}, {3, 4}, {5, 6}};
        System.out.println("Elemento de la matriz [1][1]: " + matriz[1][1]);
    }
}

4.2 Colecciones

El Framework de Colecciones de Java proporciona estructuras de datos dinámicas:

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // ArrayList (arreglo dinámico)
        ArrayList<String> nombres = new ArrayList<>();
        nombres.add("Alicia");
        nombres.add("Roberto");
        nombres.add("Carlos");
        nombres.remove("Roberto");
        System.out.println("Nombres: " + nombres);
        
        // HashMap (pares clave-valor)
        HashMap<String, Integer> edades = new HashMap<>();
        edades.put("Alicia", 25);
        edades.put("Roberto", 30);
        edades.put("Carlos", 35);
        System.out.println("Edad de Alicia: " + edades.get("Alicia"));
        
        // HashSet (elementos únicos)
        HashSet<Integer> númerosÚnicos = new HashSet<>();
        númerosÚnicos.add(1);
        númerosÚnicos.add(2);
        númerosÚnicos.add(2); // Duplicado, no se agregará
        númerosÚnicos.add(3);
        System.out.println("Números únicos: " + númerosÚnicos);
        
        // Iteración a través de colecciones
        for (String nombre : nombres) {
            System.out.println("Nombre: " + nombre);
        }
        
        for (Map.Entry<String, Integer> entrada : edades.entrySet()) {
            System.out.println(entrada.getKey() + ": " + entrada.getValue());
        }
    }
}

5. Operadores

Java proporciona varios operadores para diferentes operaciones:

Operadores aritméticos: +, -, *, /, % (módulo), ++ (incremento), -- (decremento)
Operadores de comparación: ==, !=, >, <, >=, <=
Operadores lógicos: && (y), || (o), ! (no)
Operadores bit a bit: &, |, ^, ~, <<, >>, >>>
Operadores de asignación: =, +=, -=, *=, /=, %=

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10, b = 3;
        
        // Operaciones aritméticas
        System.out.println("Suma: " + (a + b));
        System.out.println("Resta: " + (a - b));
        System.out.println("Multiplicación: " + (a * b));
        System.out.println("División: " + (a / b));
        System.out.println("Módulo: " + (a % b));
        
        // Incremento y decremento
        System.out.println("Pre-incremento: " + (++a));
        System.out.println("Post-decremento: " + (b--));
        
        // Operaciones de comparación
        System.out.println("Igual: " + (a == b));
        System.out.println("No igual: " + (a != b));
        System.out.println("Mayor que: " + (a > b));
        
        // Operaciones lógicas
        boolean x = true, y = false;
        System.out.println("Y: " + (x && y));
        System.out.println("O: " + (x || y));
        System.out.println("NO: " + (!x));
        
        // Operaciones de asignación
        int c = 5;
        c += 3; // c = c + 3
        System.out.println("Después de += 3: " + c);
    }
}

6. Control de flujo

6.1 Declaraciones condicionales

public class ConditionalExample {
    public static void main(String[] args) {
        int puntuación = 85;
        
        // Declaración if-else
        if (puntuación >= 90) {
            System.out.println("Calificación: A");
        } else if (puntuación >= 80) {
            System.out.println("Calificación: B");
        } else if (puntuación >= 70) {
            System.out.println("Calificación: C");
        } else {
            System.out.println("Calificación: F");
        }
        
        // Operador ternario
        String resultado = (puntuación >= 60) ? "Aprobado" : "Reprobado";
        System.out.println("Resultado: " + resultado);
        
        // Declaración switch
        char calificación = 'B';
        switch (calificación) {
            case 'A':
                System.out.println("¡Excelente!");
                break;
            case 'B':
                System.out.println("¡Bueno!");
                break;
            case 'C':
                System.out.println("Promedio");
                break;
            default:
                System.out.println("Calificación inválida");
        }
    }
}

6.2 Bucles

public class LoopExample {
    public static void main(String[] args) {
        // Bucle for
        System.out.println("Bucle for:");
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteración: " + i);
        }
        
        // Bucle for mejorado (for-each)
        System.out.println("\nBucle for-each:");
        int[] números = {1, 2, 3, 4, 5};
        for (int num : números) {
            System.out.println("Número: " + num);
        }
        
        // Bucle while
        System.out.println("\nBucle while:");
        int contador = 0;
        while (contador < 3) {
            System.out.println("Contador: " + contador);
            contador++;
        }
        
        // Bucle do-while
        System.out.println("\nBucle do-while:");
        int x = 0;
        do {
            System.out.println("X: " + x);
            x++;
        } while (x < 3);
        
        // break y continue
        System.out.println("\nBreak y continue:");
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break; // Salir del bucle
            }
            if (i % 2 == 0) {
                continue; // Saltar números pares
            }
            System.out.println("Número impar: " + i);
        }
    }
}

7. Métodos (Funciones)

Los métodos en Java son funciones que pertenecen a las clases:

public class MethodExample {
    
    // Método sin parámetros y sin valor de retorno
    public static void saludar() {
        System.out.println("¡Hola, Mundo!");
    }
    
    // Método con parámetros y valor de retorno
    public static int sumar(int a, int b) {
        return a + b;
    }
    
    // Método con múltiples parámetros
    public static String formatearNombre(String nombre, String apellido) {
        return nombre + " " + apellido;
    }
    
    // Sobrecarga de métodos (mismo nombre, diferentes parámetros)
    public static int multiplicar(int a, int b) {
        return a * b;
    }
    
    public static double multiplicar(double a, double b) {
        return a * b;
    }
    
    // Argumentos variables (varargs)
    public static int suma(int... números) {
        int total = 0;
        for (int num : números) {
            total += num;
        }
        return total;
    }
    
    public static void main(String[] args) {
        saludar();
        
        int resultado = sumar(5, 3);
        System.out.println("Resultado de suma: " + resultado);
        
        String nombreCompleto = formatearNombre("Juan", "Pérez");
        System.out.println("Nombre completo: " + nombreCompleto);
        
        System.out.println("Multiplicar enteros: " + multiplicar(4, 5));
        System.out.println("Multiplicar doubles: " + multiplicar(2.5, 3.0));
        
        System.out.println("Suma de múltiples números: " + suma(1, 2, 3, 4, 5));
    }
}

8. Programación orientada a objetos

8.1 Clases y objetos

public class Persona {
    // Variables de instancia (campos)
    private String nombre;
    private int edad;
    private String email;
    
    // Constructor
    public Persona(String nombre, int edad, String email) {
        this.nombre = nombre;
        this.edad = edad;
        this.email = email;
    }
    
    // Constructor por defecto
    public Persona() {
        this("Desconocido", 0, "");
    }
    
    // Métodos getter
    public String getNombre() {
        return nombre;
    }
    
    public int getEdad() {
        return edad;
    }
    
    public String getEmail() {
        return email;
    }
    
    // Métodos setter
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
    
    public void setEdad(int edad) {
        if (edad >= 0) {
            this.edad = edad;
        }
    }
    
    public void setEmail(String email) {
        this.email = email;
    }
    
    // Método de instancia
    public void presentarse() {
        System.out.println("Hola, soy " + nombre + ", tengo " + edad + " años.");
    }
    
    // Método con lógica
    public boolean esAdulto() {
        return edad >= 18;
    }
    
    // Método toString (sobrescribiendo el toString de Object)
    @Override
    public String toString() {
        return "Persona{nombre='" + nombre + "', edad=" + edad + ", email='" + email + "'}";
    }
    
    public static void main(String[] args) {
        // Creando objetos
        Persona persona1 = new Persona("Alicia", 25, "[email protected]");
        Persona persona2 = new Persona();
        
        // Usando métodos
        persona1.presentarse();
        System.out.println("Es adulto: " + persona1.esAdulto());
        
        persona2.setNombre("Roberto");
        persona2.setEdad(17);
        persona2.setEmail("[email protected]");
        
        System.out.println(persona1.toString());
        System.out.println(persona2.toString());
    }
}

Este tutorial completo de Java cubre los conceptos esenciales necesarios para comenzar con la programación en Java. El sistema de tipos fuertes, las características orientadas a objetos y la extensa biblioteca estándar de Java lo hacen poderoso para construir aplicaciones robustas. Practica estos ejemplos y experimenta con el código para profundizar tu comprensión de los conceptos de programación en Java.