> 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/excepcions-personalizadas.md).
# Excepcións Personalizadas
En Java, podes crear excepcións personalizadas definindo unha nova clase que estenda a clase `Exception`:copy: ou `RuntimeException`:copy:, dependendo de se queres que a excepción sexa verificada (*checked*) ou non (*unchecked*).
As excepcións personalizadas son útiles cando queres representar erros específicos da túa aplicación que non están cubertos polas excepcións estándar de Java.
## Como crear unha excepción personalizada
1. **Elixe a superclase**:
* Se queres unha **excepción verificada** (*checked exception*), fai que a túa clase estenda `Exception`:copy:.
* Se queres unha **excepción non verificada** (*unchecked exception*), fai que a túa clase estenda `RuntimeException`:copy:.
2. **Define un construtor**: Normalmente, creas varios construtores para pasar mensaxes ou outras excepcións encadeadas. O construtor máis común simplemente toma unha mensaxe como argumento.
3. **Implanta a clase da túa excepción**: Engade métodos adicionais ou campos se necesitas almacenar información específica do erro.
## Exemplo de Excepción Personalizada Verificada (*Checked Exception*)
Aquí creamos unha excepción chamada `ExcepcionPersonalizada`:copy: que estende `Exception`:copy:. Isto significa que será unha excepción verificada, e o compilador obrigará a manexala ou declarala.
```java
// Excepción personalizada verificada
public class ExcepcionPersonalizada extends Exception {
// Constructor sen argumentos
public ExcepcionPersonalizada() {
super("Erro personalizado ocorrido");
}
// Constructor que acepta unha mensaxe personalizada
public ExcepcionPersonalizada(String message) {
super(message);
}
// Constructor que acepta unha mensaxe e outra excepción como causa
public ExcepcionPersonalizada(String message, Throwable cause) {
super(message, cause);
}
}
```
Para usar esta excepción, poderías lanzala cunha sentenza `throw` nunha parte do código onde desexes detectar un erro específico. Aquí un exemplo de uso:
```java
public class ExemploUso {
public static void main(String[] args) {
try {
lanzarErro();
} catch (ExcepcionPersonalizada e) {
System.out.println("Capturada: " + e.getMessage());
}
}
public static void lanzarErro() throws ExcepcionPersonalizada {
throw new ExcepcionPersonalizada("Algo saiu mal.");
}
}
```
## Exemplo de Excepción Personalizada Non Verificada (*Unchecked Exception*)
Para crear unha excepción non verificada, fai que a túa clase estenda `RuntimeException`:copy:. O compilador non obrigará a manexar esta excepción.
```java
// Excepción personalizada non verificada
public class ExcepcionRuntimePersonalizada extends RuntimeException {
// Constructor sen argumentos
public ExcepcionRuntimePersonalizada() {
super("Erro en tempo de execución personalizado");
}
// Constructor que acepta unha mensaxe personalizada
public ExcepcionRuntimePersonalizada(String message) {
super(message);
}
// Constructor que acepta unha mensaxe e outra excepción como causa
public ExcepcionRuntimePersonalizada(String message, Throwable cause) {
super(message, cause);
}
}
```
E así sería o seu uso:
```java
public class ExemploUsoRuntime {
public static void main(String[] args) {
try {
lanzarErroRuntime();
} catch (ExcepcionRuntimePersonalizada e) {
System.out.println("Capturada excepción non verificada: " + e.getMessage());
}
}
public static void lanzarErroRuntime() {
throw new ExcepcionRuntimePersonalizada("Erro en tempo de execución detectado.");
}
}
```
## Consideracións ao Crear Excepcións Personalizadas
* **Usa excepcións personalizadas cando sexa necesario**: Non abuses delas. Usa excepcións personalizadas só cando teñan un significado específico para o teu dominio ou aplicación.
* **Mensaxes claras**: Sempre que sexa posible, proporciona mensaxes claras nas túas excepcións para que sexa fácil entender o erro.
* **Encadeamento de excepcións**: Usa o encadeamento (pasando a excepción orixinal) para preservar o rastro da pila de erros, o que facilita a depuración.
As excepcións personalizadas son moi útiles en Java para engadir contexto e información adicional aos erros na túa aplicación, mellorando a capacidade de depuración e mantemento do código.
---
# 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/excepcions-personalizadas.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.