> 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/ud7-poo-avanzada/clases-xenericas-xenerics/restriccions-de-clases-xenericas.md).
# Restriccións de clases xenéricas
## Herdanza
En Java, cando defines unha clase xenérica podes **acotar o tipo permitido mediante herdanza**. Isto conséguese utilizando a palabra clave **`extends`**:copy: **no parámetro xenérico**. Desta forma, limitas o tipo xenérico a unha clase específica ou ás súas subclases.
Por exemplo:
```java
class ClaseXenérica {
// Aquí, T só pode ser ClaseBase ou calquera subclase de ClaseBase
}
```
**`T extends ClaseBase`**:copy: significa que o tipo xenérico `T` debe ser de tipo `ClaseBase`:copy: ou dunha subclase dela.
Supón que tes unha xerarquía de clases:
```java
class Animal {
public void saudar() {
System.out.println("Son un animal.");
}
}
class Can extends Animal {
@Override
public void saudar() {
System.out.println("Son un can.");
}
}
class Gato extends Animal {
@Override
public void saudar() {
System.out.println("Son un gato.");
}
}
```
Agora, defines unha clase xenérica acotada a `Animal`:copy::
```java
class Caixa {
private T contido;
public void engadir(T contido) {
this.contido = contido;
}
public T obter() {
return contido;
}
public void mostrarSaudo() {
if (contido != null) {
contido.saudar(); // Método dispoñible porque T é como mínimo de tipo Animal
} else {
System.out.println("A caixa está baleira.");
}
}
}
```
E aquí temos o programa principal:
```java
public class ExemploAcotacion {
public static void main(String[] args) {
// Caixa para cans
Caixa caixaCan = new Caixa<>();
caixaCan.engadir(new Can());
caixaCan.mostrarSaudo(); // Saída: Son un can.
// Caixa para gatos
Caixa caixaGato = new Caixa<>();
caixaGato.engadir(new Gato());
caixaGato.mostrarSaudo(); // Saída: Son un gato.
// Caixa para animais en xeral
Caixa caixaAnimal = new Caixa<>();
caixaAnimal.engadir(new Animal());
caixaAnimal.mostrarSaudo(); // Saída: Son un animal.
}
}
```
## Restricións en métodos
En Java, podes usar **restricións de clases xenéricas** en métodos mediante `bounded type parameters`:copy: (``:copy:). Isto permite definir métodos que acepten só tipos que cumpran certas condicións, como herdar dunha clase determinada.
Úsase para garantir que o tipo xenérico (`T`) debe herdar dunha clase.
```java
public static void mostrarValor(T valor) {
System.out.println("O valor é: " + valor);
}
```
`T` debe ser unha subclase de `Number`:copy: (como `Integer`:copy:, `Double`:copy:, etc.). Este método non funcionará con `String`:copy:, porque `String`:copy: non herda de `Number`:copy:.
```java
mostrarValor(10); // Funciona
mostrarValor(5.5); // Funciona
mostrarValor("texto"); // ERRO: String non é subclase de Number
```
---
# 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/ud7-poo-avanzada/clases-xenericas-xenerics/restriccions-de-clases-xenericas.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.