> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud4-elementos-da-programacion-orientada-a-obxectos/xerarquia-de-excepcions.md). # Xerarquía de excepcións As excepcións en Java organizanse nunha xerarquia coma a que se presenta a continuación: {% @mermaid/diagram content="classDiagram class Throwable { +String message +Throwable cause +getMessage() String +printStackTrace() void } ``` class Error { <> } class Exception { <> } Throwable <|-- Error Throwable <|-- Exception class VirtualMachineError { <> } class LinkageError { <> } Error <|-- VirtualMachineError Error <|-- LinkageError class RuntimeException { <> } class IOException { <> } class SQLException { <> } Exception <|-- RuntimeException Exception <|-- IOException Exception <|-- SQLException class NullPointerException { <> } class IllegalArgumentException { <> } class IndexOutOfBoundsException { <> } RuntimeException <|-- NullPointerException RuntimeException <|-- IllegalArgumentException RuntimeException <|-- IndexOutOfBoundsException class ArrayIndexOutOfBoundsException IndexOutOfBoundsException <|-- ArrayIndexOutOfBoundsException class FileNotFoundException { <> } IOException <|-- FileNotFoundException" %} ``` ## Throwable A clase raíz de toda a xerarquía de excepcións, extende directamente de object e a clase que almacena a mensaxe e define os métodos principais que van a ser empregados pola xerarquía de clases. {% hint style="warning" %} Documentación oficial: {% endhint %} ## Error Os erros, derivados da clase `Error`, son problemas serios xeralmente relacionados co sistema onde se executa o programa. Non están pensados para ser manexados polo código Java, xa que normalmente representan situacións críticas, como falta de memoria ou erros no sistema. Algúns erros comúns son: * `OutOfMemoryError`: ocorre cando o Java Virtual Machine (JVM) queda sen memoria. * `StackOverflowError`: aparece cando hai un desbordamento da pila, por exemplo, debido a unha chamada recursiva infinita. * `VirtualMachineError`: indica problemas serios na propia máquina virtual de Java. ```java public class StackOverflow { // Método recursivo infinito public static void recursiveMethod() { recursiveMethod(); // Chámase a si mesmo sen condición de saída } public static void main(String[] args) { try { recursiveMethod(); } catch (StackOverflowError e) { System.out.println("StackOverflowError capturado!"); // O stack está cheo - non podemos continuar normalmente } } } ``` {% hint style="warning" %} Docuemntación oficial: {% endhint %} ## Exception Unha **excepción** é unha situación que se orixina durante a execución do programa que require que este acabe dun xeito inmediato ou que faga unha acción especial para tratala. Por exemplo un intento de división entre 0; un acceso a unha posición dun vector fora dos seus límites ou un erro durante a lectura de datos. {% hint style="warning" %} Documentación oficial: {% endhint %} Dentros das excepcións, imos atopar duas grandes familias: Excepciones verificadas e non verificadas. ### Excepcions verificadas (Checked exceptions) Son as excepcións que o **compilador esixe manexar** no momento da compilación. **Se non as manexas (usando `try-catch`** **ou lanzándoas explicitamente con `throws`****), o código non compilará.** Este tipo de excepcións xeralmente representan erros que son previsibles e que o programa debería tentar resolver ou informar. Exemplos comúns de excepcións verificadas son: * `Exception` : A propia clase exception require a sua xestión * `IOException` (Erro de entrada/saída): xorde ao traballar con ficheiros ou fluxos de datos. * `SQLException`: prodúcese ao traballar con bases de datos e consultas SQL. * `ClassNotFoundException`: ocorre cando non se pode cargar unha clase en tempo de execución. Empregaremos estas excepcións cando é o usuario o que pode arranxalo: * O erro **é esperable** * O chamador **pode recuperarse** * O fallo depende de factores externos * Queres **obrigar** a tratar o erro * P.e: Ficheiro non existe, Erro de rede, Acceso a base de datos, Lectura/escritura externa ```java public void gardarFicheiro() throws IOException ``` ### Excepcions non verificadas (Unchecked exceptions) **Estas excepcións non se verifican en tempo de compilación, polo que non é obrigatorio manexalas**. Xeralmente, indican erros en tempo de execución, moitas veces debido a erros de programación, como operar cun valor `null` ou un índice fóra dos límites. Están derivadas da clase `RuntimeException`. Algúns exemplos de excepcións non verificadas son: * `NullPointerException`: ocorre cando se intenta acceder a un obxecto que é `null`. * `ArrayIndexOutOfBoundsException`: xorde cando se intenta acceder a un índice que está fóra dos límites dun vector. * `ArithmeticException`: prodúcese ao realizar operacións matemáticas ilegais, como dividir entre cero. * `IllegalArgumentException`: aparece cando un método recibe un argumento inadecuado. Estas excepcións non daran error de compilación: ```java public static void main(String[] args) { String texto = null; int longitud = texto.length(); // ¡NULL POINTER! } ``` Ainda que tamen poden ser xestionadas: ```java public static void main(String[] args) { String texto = null; try { // Tentamos chamar un método nun obxecto null int longitud = texto.length(); // ¡NULL POINTER! } catch (NullPointerException e) { System.out.println("NullPointerException capturada!"); System.out.println("Mensaxe: " + e.getMessage()); System.out.println("Localización: " + e.getStackTrace()[0]); } } ``` Empregaremos estas excepcións cando o programador debe de arranxalo, xa que: * O erro indica un **bug** * Non ten sentido recuperarse * O erro débese a **mal uso da API** * Queres código máis limpo e flexible * P.e: Parámetros invalidos, xestión de nulos, indices fora de rango, estados imposibles,... ```java public void setId(int id) { if (id <= 0) { throw new IllegalArgumentException("Id inválido"); } } ``` --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://educacion.gitbook.io/programacion/ud4-elementos-da-programacion-orientada-a-obxectos/xerarquia-de-excepcions.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.