RuntimeException în Java

public class RuntimeException extends Exception

RuntimeException(String mesaj)
RuntimeException(String mesaj, Throwable cauza)

Ce face RuntimeException

RuntimeException și subclasele ei (NullPointerException, IllegalArgumentException, ArithmeticException, IndexOutOfBoundsException …) sunt excepții neverificate: compilatorul nu te obligă să le prinzi sau să le declari cu throws.

De obicei arată o greșeală de programare sau o folosire greșită a unei metode: un argument invalid, un obiect null, un indice în afara tabloului. Soluția este de obicei să corectezi codul, nu să prinzi excepția.

Excepțiile proprii neverificate extind RuntimeException. Se mai folosește pentru a „înveli” o excepție verificată acolo unde nu o poți declara, de exemplu într-o lambda: throw new RuntimeException(e) (sau UncheckedIOException pentru IOException).

Parametri

Parametru	Descriere
mesaj	Descrierea erorii.
cauza	Excepția învelită, dacă există.

Ce returnează

Un obiect excepție; se aruncă cu throw.

Exemple

Exemplul 1: Excepție proprie neverificată

Metoda retrage nu are throws, totuși codul compilează.

public class Main {
    static class SoldInsuficientException extends RuntimeException {
        private static final long serialVersionUID = 1L;

        SoldInsuficientException(int sold, int suma) {
            super("Sold " + sold + " lei, retragere cerută " + suma + " lei");
        }
    }

    static int sold = 250;

    static void retrage(int suma) {
        if (suma > sold) throw new SoldInsuficientException(sold, suma);
        sold -= suma;
        System.out.println("Retras " + suma + " lei, rămân " + sold);
    }

    public static void main(String[] args) {
        retrage(100);
        try {
            retrage(500);
        } catch (SoldInsuficientException e) {
            System.out.println("Refuzat: " + e.getMessage());
        }
    }
}

Rezultat

Retras 100 lei, rămân 150
Refuzat: Sold 150 lei, retragere cerută 500 lei

Exemplul 2: Învelirea unei excepții verificate într-o lambda

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.List;

public class Main {
    public static void main(String[] args) throws IOException {
        Files.writeString(Path.of("iasi.txt"), "Iași: 14°C");
        Files.writeString(Path.of("cluj.txt"), "Cluj: 11°C");
        List<String> fisiere = List.of("iasi.txt", "cluj.txt", "brasov.txt");
        try {
            fisiere.forEach(f -> {
                try {
                    System.out.println(Files.readString(Path.of(f)));
                } catch (IOException e) {
                    throw new UncheckedIOException("nu pot citi " + f, e);
                }
            });
        } catch (UncheckedIOException e) {
            System.out.println("Oprit: " + e.getMessage() + " (cauza: " + e.getCause().getClass().getSimpleName() + ")");
        }
    }
}

Rezultat

Iași: 14°C
Cluj: 11°C
Oprit: nu pot citi brasov.txt (cauza: NoSuchFileException)

Exemplul 3: Verificată sau neverificată?

import java.io.IOException;

public class Main {
    static String tip(Exception e) {
        return e instanceof RuntimeException ? "neverificată" : "verificată";
    }

    public static void main(String[] args) {
        Exception[] exceptii = {
            new IOException(), new IllegalArgumentException(), new NullPointerException(),
            new InterruptedException(), new ArithmeticException(), new Exception(),
        };
        for (Exception e : exceptii) {
            System.out.println(e.getClass().getSimpleName() + ": " + tip(e));
        }
    }
}

Rezultat

IOException: verificată
IllegalArgumentException: neverificată
NullPointerException: neverificată
InterruptedException: verificată
ArithmeticException: neverificată
Exception: verificată

Greșeli frecvente

• Prinzi RuntimeException ca să ascunzi greșeli de programare (de exemplu NullPointerException). Repară cauza.
• Faci toate excepțiile proprii neverificate doar ca să nu scrii throws. Pentru erori pe care apelantul trebuie să le trateze (fișier lipsă, plată refuzată), o excepție verificată este mai clară.

Comenzi înrudite

• Exception: Clasa de bază pentru erorile pe care un program le poate trata; getMessage() returnează mesajul dat la creare.
• IllegalArgumentException: Excepția aruncată când o metodă primește un argument cu valoare nepermisă (vârstă negativă, lună 13).
• NullPointerException: Apare când folosești o referință null ca pe un obiect (apelezi o metodă, citești un câmp); mesajul spune ce era null.
• Exception.getCause: Returnează excepția originală care a produs-o pe aceasta (lanț de excepții), sau null dacă nu există.