Captura de datos desde consola

Para leer información del usuario empleamos la clase java.util.Scanner. El flujo típico consiste en importar la clase, instanciar un objeto y utilizar sus métodos next(), nextInt() o nextDouble() según el tipo esperado.

import java.util.Scanner;

public class EntradaConsola {
    public static void main(String[] args) {
        Scanner lector = new Scanner(System.in);

        System.out.print("Nombre: ");
        String nombre = lector.next();

        System.out.print("Edad: ");
        int edad = lector.nextInt();

        System.out.print("Salario: ");
        double salario = lector.nextDouble();

        System.out.printf("Datos -> %s, %d años, $%.2f%n", nombre, edad, salario);
    }
}

Tabla de multiplicar con bucles anidados

Un clásico para practicar for anidados es la tabla Pitágoras del 1 al 9:

public class TablaMultiplicar {
    public static void main(String[] args) {
        for (int fila = 1; fila <= 9; fila++) {
            for (int col = 1; col <= fila; col++) {
                System.out.print(col + "×" + fila + "=" + (fila * col) + "\t");
            }
            System.out.println();
        }
    }
}

Clases y objetos básicos

Una clase define el "molde"; un objeto es la instancia concreta. A continuación se crea la clase Gato y se utilizan sus atributos:

public class DemoGato {
    public static void main(String[] args) {
        Gato michi = new Gato();
        michi.nombre = "Luna";
        michi.edad   = 3;
        michi.color  = "negro";
        System.out.println(michi);
    }
}

class Gato {
    String nombre;
    int    edad;
    String color;
}

Métodos de instancia

Los métodos encapsulan comportamiento y pueden recibir parámetros o devolver valores. Ejemplo con tres utilidades:

class CalculadoraHumana {
    public void saludo() {
        System.out.println("¡Hola!");
    }

    public int sumatoria(int limite) {
        int total = 0;
        for (int i = 1; i <= limite; i++) total += i;
        return total;
    }

    public int suma(int a, int b) {
        return a + b;
    }
}

Sobrecarga de métodos

Java permite varios métodos con el mismo nombre siempre que difieren en firma (tipo, número u orden de parámetros):

class Calculadora {
    public int    add(int a, int b)          { return a + b; }
    public double add(int a, double b)       { return a + b; }
    public double add(double a, int b)       { return a + b; }
    public int    add(int a, int b, int c)   { return a + b + c; }
}

Parámetros variables (varargs)

Desde Java 5 podemos declarar métodos que acepten un número arbitrario de argumentos del mismo tipo:

public int sumar(int... numeros) {
    int total = 0;
    for (int n : numeros) total += n;
    return total;
}

Ámbito de variables

Las variables de instancia (atributos) viven mientras exista el objeto; las locales solo dentro del bloque o método donde se declaran. Ejemplo de sombreado:

class DemoAmbito {
    int valor = 10;

    void mostrar() {
        int valor = 5;        // sombrea al atributo
        System.out.println(valor);          // 5
        System.out.println(this.valor);     // 10
    }
}

Constructores

Se ejecutan automáticamente al crear un objetto. Permiten inicializar el estado de forma controlada:

class Libro {
    String titulo;
    double precio;

    public Libro(String titulo, double precio) {
        this.titulo = titulo;
        this.precio = precio;
    }
}

Palabra clave this

Resuelve ambigüedades entre parámetros y atributos, y permite invocar a otros constructores de la misma clase:

class Empleado {
    String nombre;
    int edad;

    public Empleado() { this("Sin nombre", 18); }

    public Empleado(String nombre, int edad) {
        this.nombre = nombre;
        this.edad   = edad;
    }
}

Recursividad

Un método puede invocarse a sí mismo para resolver subproblemas más pequeños:

public int factorial(int n) {
    if (n == 1) return 1;
    return n * factorial(n - 1);
}

Herencia y super

Con extends reutilizamos código. Con super accedemos a miembros del padre:

class Vehiculo {
    int velocidadMax = 120;
}

class Coche extends Vehiculo {
    int velocidadMax = 180;

    void mostrarMax() {
        System.out.println(super.velocidadMax); // 120
        System.out.println(this.velocidadMax);  // 180
    }
}

Polimorfismo

El polimorfismo permite tratar objetos de distintas clases mediante una referencia común. Ejemplo con animales:

Animal a = new Perro();   // up-casting
a.sonido();               // ejecuta el de Perro
((Perro) a).ladrar();   // down-casting para métodos propios

Encapsulamiento

Ocultamos datos internos y exponemos solo operaciones seguras:

class CuentaBancaria {
    private double saldo;

    public void depositar(double cantidad) {
        if (cantidad > 0) saldo += cantidad;
    }

    public double getSaldo() { return saldo; }
}

Clases y métodos estáticos

Pertanecen a la clase, no a las instancias, y se comparten entre todos los objetos:

class Contador {
    static int total = 0;

    public Contador() { total++; }
    public static int obtenerTotal() { return total; }
}

Clases internas

Permiten agrupar lógica relacionada y acceder a miembros privados del exterior:

class Exterior {
    private int secreto = 42;

    class Interior {
        void mostrar() {
            System.out.println(secreto);
        }
    }
}

Enumeraciones

Conjunto finito de constantes con nombre:

enum Dia { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES }

Interfaces

Contratos que obligan a las clases a implementar ciertos métodos:

interface Imprimible {
    void imprimir();
}

class Documento implements Imprimible {
    public void imprimir() { System.out.println("Imprimiendo..."); }
}

Gestión de excepciones

Capturamos errores para evitar fallos críticos y ofrecer mensajes claros:

try {
    int x = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("División por cero");
} finally {
    System.out.println("Operación finalizada");
}

Clases de utilidad

Java proporciona utilidades para arrays, fechas, matemáticas, etc. Ejemplos breves:

int[] nums = {5, 2, 9};
Arrays.sort(nums);

BigDecimal precio = new BigDecimal("19.99");
BigDecimal iva     = precio.multiply(new BigDecimal("0.21"));

LocalDate hoy = LocalDate.now();
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("dd/MM/yyyy");
System.out.println(hoy.format(fmt));