Al enfrentarnos a una excepción solo existen tres salidas posibles.

ArrayList<String> nombres = new ArrayList<>();
nombres.add("Ana");

// IndexOutOfBoundsException: solo existe el índice 0
System.out.println(nombres.get(5));

Scanner teclado = new Scanner(System.in);

try {
    System.out.print("Ingrese su edad: ");
    String entrada = teclado.nextLine();
    int edad = Integer.parseInt(entrada);
    System.out.println("Edad: " + edad);
} catch (NumberFormatException e) {
    System.out.println("Error: ingrese un número entero.");
}

try {
    Files.readString(Path.of("data.txt"));
} catch (FileNotFoundException e) {
    System.out.println("Archivo no encontrado");
} catch (IOException e) {
    System.out.println("Error de entrada o salida");
}

Cuando varias excepciones se manejan igual, se agrupan en un solo catch.

try {
    Files.readString(Path.of("data.txt"));
} catch (NoSuchFileException | AccessDeniedException e) {
    System.out.println("Archivo inaccesible");
} catch (IOException e) {
    e.printStackTrace();
}

try {
    int resultado = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println(e.getMessage());
    e.printStackTrace();
}

Un archivo abierto debe cerrarse siempre, haya funcionado la lectura o no.

FileReader fr = null;

try {
    fr = new FileReader("data.txt");
    System.out.println(fr.read());
} catch (IOException e) {
    System.out.println("Error de lectura");
} finally {
    if (fr != null) {
        fr.close();
    }
}

Las dos versiones abren el mismo archivo y lo cierran igual de bien.

FileReader fr = null;

try {
    fr = new FileReader("data.txt");
} catch (IOException e) {
    System.out.println("Error");
} finally {
    if (fr != null) {
        fr.close();
    }
}

try (FileReader fr = new FileReader("data.txt")) {

    // Java cierra fr al salir

} catch (IOException e) {
    System.out.println("Error");
}

El recurso se declara entre los paréntesis que van justo después de la palabra try.

try (FileReader fr = new FileReader("data.txt")) {
    System.out.println(fr.read());
} catch (IOException e) {
    System.out.println("Error de lectura");
}

La palabra clave throw genera una excepción al detectar una condición inválida.

public int dividir(int a, int b) {
    if (b == 0) {
        throw new IllegalArgumentException("b != 0");
    }

    return a / b;
}

La cláusula throws se escribe en la firma del método, antes de abrir la llave.

public void cargar() throws IOException {
    Files.readString(Path.of("config.json"));
}

Al ver el letrero, quien llama a cargar elige entre resolver el problema o volver a pasarlo.

public void iniciar() {
    try {
        cargar();
    } catch (IOException e) {
        System.out.println("No se pudo cargar");
    }
}

public void iniciar() throws IOException {

    cargar();

}

Mientras nadie la capture, la excepción sigue subiendo por los métodos que llamaron.

Ninguna de estas dos clases resuelve el problema: las dos solo lo anuncian.

// Clase 1: aquí ocurre el problema
public class Lector {
    public String leer(String ruta) throws IOException {
        return Files.readString(Path.of(ruta));
    }
}

// Clase 2: no lo resuelve, repite el letrero
public class Configuracion {
    private Lector lector = new Lector();

    public String cargar() throws IOException {
        return lector.leer("config.json");
    }
}

// Clase 3: aquí sí se decide qué hacer
public class Main {
    public static void main(String[] args) {
        Configuracion config = new Configuracion();

        try {
            System.out.println(config.cargar());
        } catch (IOException e) {
            System.out.println("No se pudo leer la configuración");
        }
    }
}

Extiende Exception para una chequeada, o RuntimeException para una no chequeada.

public class SaldoInsuficienteException extends RuntimeException {
    public SaldoInsuficienteException(String mensaje) {
        super(mensaje);
    }
}

public class OperacionBancariaException extends Exception {
    private final String cuenta;
    private final double monto;

    public OperacionBancariaException(String cta, double monto, String msg) {
        super(msg);
        this.cuenta = cta;
        this.monto = monto;
    }

    public String getCuenta() { return cuenta; }
    public double getMonto() { return monto; }
}

public void retirar(double monto) {
    if (monto > saldo) {
        throw new SaldoInsuficienteException("Saldo insuficiente");
    }

    saldo -= monto;
}