Palabras reservadas en Java: lista completa con ejemplos y descripción

public class EjemploError {
    public static void main(String[] args) {
        // ❌ ERROR DE COMPILACIÓN: 'class' es palabra reservada
        // int class = 10;

        // ✅ CORRECTO: usar un nombre descriptivo
        int clase = 10;
        System.out.println("Valor: " + clase); // Salida: Valor: 10
    }
}

public class TiposPrimitivos {
    public static void main(String[] args) {
        byte   edadMascota   = 12;
        short  alturaEdificio = 452;
        int    habitantes    = 3280000;
        long   distanciaLuna = 384400000L;
        float  notaMedia     = 7.85f;
        double tasaInteres   = 3.141592653589793;
        char   inicial       = 'J';
        boolean esMayorEdad  = true;

        System.out.println("Edad mascota: " + edadMascota);
        System.out.println("Altura edificio: " + alturaEdificio + " m");
        System.out.println("Habitantes: " + habitantes);
        System.out.println("Distancia Luna: " + distanciaLuna + " km");
        System.out.println("Nota media: " + notaMedia);
        System.out.println("Tasa interés: " + tasaInteres);
        System.out.println("Inicial: " + inicial);
        System.out.println("Mayor de edad: " + esMayorEdad);
    }
}
// Salida:
// Edad mascota: 12
// Altura edificio: 452 m
// Habitantes: 3280000
// Distancia Luna: 384400000 km
// Nota media: 7.85
// Tasa interés: 3.141592653589793
// Inicial: J
// Mayor de edad: true

public class ControlFlujo {
    public static void main(String[] args) {
        // for + if + else + continue + break
        for (int i = 1; i <= 20; i++) {
            if (i % 15 == 0) {
                System.out.println(i + " → FizzBuzz");
                break;      // sale del bucle al encontrar el primer FizzBuzz
            } else if (i % 3 == 0) {
                continue;   // salta los múltiplos de 3 puros
            } else {
                System.out.println(i);
            }
        }

        // switch + case + default
        String dia = "LUNES";
        switch (dia) {
            case "LUNES":
            case "MARTES":
            case "MIERCOLES":
            case "JUEVES":
            case "VIERNES":
                System.out.println(dia + " es día laborable");
                break;
            default:
                System.out.println(dia + " es fin de semana");
        }
    }
}
// Salida:
// 1
// 2
// 4
// 5
// 7
// 8
// 10
// 11
// 13
// 14
// 15 → FizzBuzz
// LUNES es día laborable

public class Configuracion {
    // static + final = constante de clase
    public static final double IVA = 0.21;
    public static final String MONEDA = "EUR";

    // static: pertenece a la clase, no a cada objeto
    private static int contadorInstancias = 0;

    private String nombre;

    public Configuracion(String nombre) {
        this.nombre = nombre;
        contadorInstancias++;  // se incrementa con cada objeto creado
    }

    public static int getContadorInstancias() {
        return contadorInstancias;
    }

    public static void main(String[] args) {
        Configuracion c1 = new Configuracion("Servidor A");
        Configuracion c2 = new Configuracion("Servidor B");

        System.out.println("IVA: " + IVA);                        // 0.21
        System.out.println("Moneda: " + MONEDA);                  // EUR
        System.out.println("Instancias: " + getContadorInstancias()); // 2

        // ❌ ERROR: no se puede reasignar una variable final
        // IVA = 0.10;
    }
}
// Salida:
// IVA: 0.21
// Moneda: EUR
// Instancias: 2

// Interfaz con palabra clave 'interface'
interface Describible {
    String describir();
}

// Clase padre con 'class'
class Animal {
    protected String nombre;

    public Animal(String nombre) {
        this.nombre = nombre;   // 'this' referencia al objeto actual
    }

    public String getNombre() {
        return nombre;
    }
}

// Clase hija con 'extends' e 'implements'
class Perro extends Animal implements Describible {
    private String raza;

    public Perro(String nombre, String raza) {
        super(nombre);          // 'super' llama al constructor padre
        this.raza = raza;
    }

    @Override
    public String describir() {
        return nombre + " es un " + raza;
    }
}

// Uso con 'new' e 'instanceof'
public class EjemploPOO {
    public static void main(String[] args) {
        Perro miPerro = new Perro("Rex", "Pastor Alemán");
        System.out.println(miPerro.describir());

        if (miPerro instanceof Animal) {
            System.out.println(miPerro.getNombre() + " es un Animal");
        }
        if (miPerro instanceof Describible) {
            System.out.println(miPerro.getNombre() + " es Describible");
        }
    }
}
// Salida:
// Rex es un Pastor Alemán
// Rex es un Animal
// Rex es un Describible

public class EjemploExcepciones {

    // 'throws' declara que el método puede lanzar una excepción
    public static int dividir(int dividendo, int divisor) throws ArithmeticException {
        if (divisor == 0) {
            // 'throw' lanza la excepción explícitamente
            throw new ArithmeticException("No se puede dividir entre cero");
        }
        return dividendo / divisor;
    }

    public static void main(String[] args) {
        // 'try' envuelve el código que puede fallar
        try {
            int resultado = dividir(10, 0);
            System.out.println("Resultado: " + resultado);
        }
        // 'catch' captura la excepción
        catch (ArithmeticException e) {
            System.out.println("Error: " + e.getMessage());
        }
        // 'finally' se ejecuta SIEMPRE
        finally {
            System.out.println("Bloque finally ejecutado");
        }
    }
}
// Salida:
// Error: No se puede dividir entre cero
// Bloque finally ejecutado

// Desde Java 10: var infiere el tipo automáticamente
var mensaje = "Hola, Java";         // String inferido
var numeros = List.of(1, 2, 3, 4);  // List<Integer> inferido
var mapa = new HashMap<String, Integer>(); // HashMap inferido

// NOTA: var solo funciona en variables locales, no en campos de clase
// ni en parámetros de métodos

// === Palabras usadas: package, import, enum, interface, class, extends,
//     implements, public, private, protected, static, final, abstract,
//     new, this, super, if, else, for, switch, case, default, break,
//     return, try, catch, throw, throws, instanceof, void, boolean,
//     int, double, char ===

// Enum: categorías de producto
enum Categoria {
    ELECTRONICA, ROPA, ALIMENTACION, HOGAR
}

// Interfaz: contrato para objetos con descuento
interface Descontable {
    double aplicarDescuento(double porcentaje);
}

// Clase abstracta: base para todos los productos
abstract class Producto {
    private static int contadorId = 0;      // static: compartido
    protected final int id;                 // final: no cambia
    protected String nombre;
    protected double precio;
    protected Categoria categoria;

    public Producto(String nombre, double precio, Categoria categoria) {
        this.id = ++contadorId;             // this: referencia actual
        this.nombre = nombre;
        this.precio = precio;
        this.categoria = categoria;
    }

    // Método abstracto: cada subclase lo implementa
    abstract String getEtiqueta();

    public static int getTotalProductos() {
        return contadorId;
    }

    @Override
    public String toString() {
        return "[" + id + "] " + nombre + " - " + precio + " €";
    }
}

// Clase concreta que hereda e implementa
class ProductoFisico extends Producto implements Descontable {
    private double pesoKg;

    public ProductoFisico(String nombre, double precio, Categoria cat, double pesoKg) {
        super(nombre, precio, cat);         // super: constructor padre
        this.pesoKg = pesoKg;
    }

    @Override
    String getEtiqueta() {
        return nombre + " (" + pesoKg + " kg)";
    }

    @Override
    public double aplicarDescuento(double porcentaje) {
        if (porcentaje < 0 || porcentaje > 100) {
            throw new IllegalArgumentException("Porcentaje inválido: " + porcentaje);
        }
        double descuento = precio * porcentaje / 100;
        return precio - descuento;
    }
}

// Programa principal
public class TiendaOnline {
    public static void main(String[] args) {
        // Crear productos con 'new'
        ProductoFisico[] catalogo = {
            new ProductoFisico("Portátil", 899.99, Categoria.ELECTRONICA, 1.8),
            new ProductoFisico("Camiseta", 29.95, Categoria.ROPA, 0.2),
            new ProductoFisico("Arroz 1kg", 1.50, Categoria.ALIMENTACION, 1.0),
            new ProductoFisico("Lámpara LED", 45.00, Categoria.HOGAR, 0.5)
        };

        System.out.println("=== CATÁLOGO (" + Producto.getTotalProductos() + " productos) ===");

        // for-each + switch + case + default
        for (Producto prod : catalogo) {
            System.out.println(prod);

            // instanceof: verificar tipo
            if (prod instanceof Descontable) {
                Descontable d = (Descontable) prod;
                // switch sobre la categoría
                double descuento;
                switch (prod.categoria) {
                    case ELECTRONICA: descuento = 10; break;
                    case ROPA:        descuento = 25; break;
                    default:          descuento = 5;  break;
                }
                // try-catch: manejar posible error
                try {
                    double precioFinal = d.aplicarDescuento(descuento);
                    System.out.println("   → Con " + descuento + "% dto: "
                                       + String.format("%.2f", precioFinal) + " €");
                } catch (IllegalArgumentException e) {
                    System.out.println("   → Error: " + e.getMessage());
                }
            }
        }
    }
}
// Salida:
// === CATÁLOGO (4 productos) ===
// [1] Portátil - 899.99 €
//    → Con 10.0% dto: 809.99 €
// [2] Camiseta - 29.95 €
//    → Con 25.0% dto: 22.46 €
// [3] Arroz 1kg - 1.5 €
//    → Con 5.0% dto: 1.43 €
// [4] Lámpara LED - 45.0 €
//    → Con 5.0% dto: 42.75 €

int new = 5;       // ❌ Error: 'new' es palabra reservada
String class = ""; // ❌ Error: 'class' es palabra reservada
double void = 3.0; // ❌ Error: 'void' es palabra reservada

int nuevoValor = 5;
String nombreClase = "";
double resultado = 3.0;

const double PI = 3.14159; // ❌ Error: 'const' no se usa en Java

final double PI = 3.14159; // ✅ 'final' es la forma correcta en Java

Public Static Void main(String[] args) { } // ❌ Error de compilación

public static void main(String[] args) { } // ✅ Siempre en minúsculas

goto inicio; // ❌ Error: 'goto' está reservada pero no implementada

// Usar break con etiqueta como alternativa
externo:
for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 6) {
            break externo; // Sale de ambos bucles
        }
    }
}