> 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/herdanza-clases-abstractas.md).

# Herdanza: Clases abstractas

Cando traballamos con unha xerarquía de clases, **canto mas arriba esté unha clase, mais xeral e abstracta** é, mentres que **canto mais abaixo, mais especifica e concreta**

{% @mermaid/diagram content="graph TD
A\[Clase Xeral<br>Abstracta] --> B\[Clase Intermedia]
B --> C\[Clase Específica<br>Concreta]

```
A --> D[Outra Clase Intermedia]
D --> E[Outra Clase Específica<br>Concreta]" %}
```

## Clases abstractas

Unha **clase abstracta** é unha clase que serve como modelo xeral dentro dunha xerarquía de herdanza e que se caracteriza porque:

* Empregan na súa definición a palabra reservada **abstract** previamente a empregar a palabra reservada class
* **Non pode ser instanciada,** pero permite definir constructores para a súa reutilización na xerarquía.
* Si **se pode empregar** como tipo a declarar para o uso de **polimorfísmo.**
* O seu propósito e que outras clases mais específicas estendan de ela.
* Permite a definición de caracteristicas é comportamentos comunes na xerarquía
* Permiten a definición de atributos e métodos con diferentes tipos e visibilidades igual que as clases mais específicas
* Permiten a definición de **métodos abstractos.**

```java
public abstract class ClaseAbstracta {
    
    private String atributo;

    public ClaseAbstracta(String atributo) {
        this.atributo = atributo;
    }

    public String getAtributo() {
        return atributo;
    }

    public void setAtributo(String atributo) {
        this.atributo = atributo;
    }
    
    public void metodo1(){
        System.out.println("Este é o método 1");
    }
}
```

```java
ClaseAbstracta c1 = new ClaseAbstracta("Hola"); //Error de compilación
```

## Métodos abstractos

Un método abstracto tratase de un **método específico de unha clase abstracta** que ten definida unha firma e un tipo de retorno, pero non unha implementación, e forza ás subclases que o implementen:

```java
public abstract void metodo2();
```

{% hint style="warning" %}
O **obxectivo** de estes métodos abstractos é **forzar un comportamento ou operación que se ten que realizar nunha xerarquía, pero que vai a ser totalmente diferente para cada unha das clases** que a compoñen
{% endhint %}

```java
public abstract class ClaseAbstracta {
    
    private String atributo;

    public ClaseAbstracta(String atributo) {
        this.atributo = atributo;
    }

    public String getAtributo() {
        return atributo;
    }

    public void setAtributo(String atributo) {
        this.atributo = atributo;
    }
    
    public void metodo1(){
        System.out.println("Este é o método 1");
    }
    
    public abstract void metodo2();
}
```

## Herdanza e polimorfismo

A partir da clase abstracta anterior e posible traballar na xerarquía coas ferramentas de herdanza e polimorfismo:

```java
public class ClaseConcreta1 extends ClaseAbstracta{
    
    public ClaseConcreta1(String a){
        super(a);
    }
    
    @Override
    public void metodo2() {
        System.out.println("Esta é a ClaseConcreta1");
    }
}
```

```java
public class ClaseConcreta2 extends ClaseAbstracta{

    public ClaseConcreta2(String a){
        super(a);
    }

    @Override
    public void metodo2() {
        System.out.println("Esta é a ClaseConcreta2");
    }
}
```

```java
ClaseAbstracta c1 = new ClaseConcreta1("Clase 1");
ClaseAbstracta c2 = new ClaseConcreta2("Clase 2");
c1.metodo1();
c1.metodo2();
System.out.println("C1" + c1.getAtributo());
c2.metodo1();
c2.metodo2();
System.out.println("C2" + c2.getAtributo());
```

## Clases abstractas vs Interfaces

| Característica     | Clase abstracta                                    | Interface                                                                                                          |
| ------------------ | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| Herdanza           | Só unha clase pode ser estendida (herdanza simple) | Pode ser implementada por varias clases (herdanza múltiple de tipos)                                               |
| Métodos con código | Pode ter métodos implementados                     | Java 8+ permite métodos por defecto (`default`) e estáticos; pero sen estado (antes Java 8, só métodos abstractos) |
| Atributos          | Pode ter atributos con estado                      | Só constantes públicas (`public static final`)                                                                     |
| Constructores      | Si, poden ter constructores                        | Non ten constructores                                                                                              |
| Obxectos           | Non se pode instanciar                             | Non se pode instanciar                                                                                             |
| Polimorfismo       | Si, pode usarse como tipo                          | Si, pode usarse como tipo                                                                                          |

{% hint style="warning" %}
**¿Cando emprego interfaces e cando clases abstractas?**

**Clases abstractas**: cando queres **compartir atributos e implementación** entre varias subclases

**Interfaces:** cando queres definir un **contrato común** que varias clases poden implementar sen importar a súa posición na xerarquía.
{% endhint %}


---

# 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/herdanza-clases-abstractas.md?ask=<question>
```

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.