> 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/ud5-entrada-e-saida-da-informacion/interfaces.md).

# Interfaces

<figure><img src="/files/A3Mq50JVC7Qur5oS9ZGt" alt=""><figcaption></figcaption></figure>

En Java, unha **interface é unha colección de métodos abstractos** (sen implantación) e constantes que **define un comportamento** que outras clases poden implantar. As interfaces proporcionan un medio para que clases non relacionadas compartan métodos comúns, sen necesidade de herdar dunha clase común.

As características principais dunha interface en Java son:

* **Definición de comportamento**: Contén métodos abstractos (ata Java 7) ou métodos con implantación por defecto (dende Java 8 en adiante).
* **Implantación múltiple**: Unha clase pode implantar varias interfaces, o que permite simular unha forma de herdanza múltiple.

As interfaces non poden ser instanciables, é dicir, **non se poden crear obxectos dunha interface**.

## Definición de interfaces

Unha interface definie tradicionalmente un contrato, que indica que métodos deben de definri as clases que a implementan, pero non como se implementan. É dicir:

* Non ten lóxica (Aínda que os métodos por defecto están permitido desde Java 8)
* Non garda atributos normais, pero permite a definición que son **públicos, estáticos e finais por defecto** (Constantes)
* Obriga ás clases que a implementan a definir os seus métodos

```java
public interface Calculable {
  public double area();
  public double perimetro();
}
```

```java
public class Circulo implements Calculable {

    private double radio;

    public Circulo(double radio) {
        this.radio = radio;
    }

    @Override
    public double area() {
        return Math.PI * radio * radio;
    }

    @Override
    public double perimetro() {
        return 2 * Math.PI * radio;
    }
}

```

```java
public class Rectangulo implements Calculable {

    private double ancho;
    private double alto;

    public Rectangulo(double ancho, double alto) {
        this.ancho = ancho;
        this.alto = alto;
    }

    @Override
    public double area() {
        return ancho * alto;
    }

    @Override
    public double perimetro() {
        return 2 * (ancho + alto);
    }
}

```

Neste caso, a interface Figura vai a obrigar a todas as clases que as implementen a implementar os métodos do servicio

## Interface como tipo de dato. Polimorfismo.

Unhas das principiáis potencialidades das interfaces é que unha interface pode empregarse como tipo de dato, e invocar aos seus métodos mediante polimorfismo dinamico. Por exemplo:

```java
Calculable c = new Circulo(2.0);
Calculable r = new Rectangulo(4.0,5.0);
Calculable[] lista = new Calculable[2];
lista[0] = c;
lista[1] = r;
for (Calculable c: lista){
     System.out.println("Área: " + c.area());
}
```

## Interfaces vs Herdanza

| **Característica** | **Herdanza**                               | **Interfaces**                                |
| ------------------ | ------------------------------------------ | --------------------------------------------- |
| **Relación**       | "É un" (is-a)                              | "Pode facer" (can-do)                         |
| **Código**         | Reutilización de código implementado       | Só definición de métodos (sen implementación) |
| **Acoplamento**    | Alto acoplamento entre clases              | Baixo acoplamento                             |
| **Flexibilidade**  | Menos flexible (herdanza simple)           | Máis flexible (múltiples interfaces)          |
| **Estrutura**      | Clases comparten estrutura e comportamento | Clases poden ter estruturas diferentes        |
| **Exemplo**        | `Coche extends Vehiculo`                   | `Coche implements Conducible`                 |

```java
// HERDANZA - Relación "é un"
public class Vehiculo {
    protected String matricula;
    public void mover() { /* ... */ }
}

public class Coche extends Vehiculo {
    // Reutiliza matricula e mover()
    // Engade funcionalidade específica
}

// INTERFACE - Relación "pode facer"
public interface Conducible {
   public void conducir();
   public void aparcar();
}

public class Coche extends Vehiculo implements Conducible {
    
    private boolean enMarcha;

    public Coche(String matricula) {
        this.matricula = matricula;
        this.enMarcha = false;
    }

    @Override
    public void conducir() {
        if (!enMarcha) {
            enMarcha = true;
            System.out.println("O coche coa matrícula " + matricula + " está en marcha.");
        } else {
            System.out.println("O coche xa estaba en marcha.");
        }
    }

    @Override
    public void aparcar() {
        if (enMarcha) {
            enMarcha = false;
            System.out.println("O coche coa matrícula " + matricula + " está aparcado.");
        } else {
            System.out.println("O coche xa estaba parado.");
        }
    }
}

```

{% hint style="info" %}
**¿Cando empregar?**

**Herdanza**: Cando hai unha relación clara de especialización e queremos reutilizar código

**Interfaces**: Cando queremos definir capacidades que poden ser implementadas por clases non relacionadas
{% 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/ud5-entrada-e-saida-da-informacion/interfaces.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.