> 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/caracteristicas-da-poo.md).

# Características da POO

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

A **programación orientada a obxectos** e un paradigma que se basea na creación de un conxunto de obxectos, relevantes para o dominio de resolución do problema, que interatuan entre si para resolver o problema a tratar.

## Características das linguaxes OO

As linguaxes orientadas a obxectos caracterizanse polo seguinte:

### Uso de clases

Na POO empregamos clases, que son "moldes" que permiten definir as características e operacións que van a ter todos os elementos pertencentes a esas clases

```java
public class Persona {
    private String nombre;
    private String dni;
    public Persona(String nombre, String dni) {
        this.nombre = nombre;
        this.dni = dni;
    }

    public Persona(){
        this("","");
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getDni() {
        return dni;
    }

    public void setDni(String dni) {
        this.dni = dni;
    }
    
    void presentarse() {
        System.out.println("Ola, chámome " + nome + " e teño " + idade + " anos.");
    }

    void falar(Persoa p) {
        System.out.println(nome + " está falando con " + p.nome);
        presentarse();
        p.presentarse();
    } 

    @Override
    public String toString() {
        return "Persona{" +
                "nombre='" + nombre + '\'' +
                ", dni='" + dni + '\'' +
                '}';
    }
}
```

### Comunicación mediante mensaxes

A comunicación entre obxectos vaise a realizar mediante o pase de mensaxes. Unha mensaxe consta de:

1. Identidade do obxecto receptor
2. Método que vai a executar este obxecto
3. Parametros que ten que recibir o obxecto para executarse

Desde unha clase main, estamos a chamar ao id de obxecto ana, co método falar, e que recibe como parametro o obxecto pepe

```java
Persona pepe = new Persona("Pepe", "12345678Z");
Persona ana = new Persona("Ana", "98765432A");
ana.falar(pepe);
```

Internamente, o método falar vai a realizar duas chamadas a mensaxes:

* Unha mensaxe ao propio obxecto co identificador this, a mensaxe presentarse e uha cadea saudo
* Outra mensaxe ao obxecto co identificador recibido como parametro, a mensaxe presentarse e uha cadea saudo

```java
 public void falar(Persona p) {
        System.out.println(this.getNombre() + " está falando con " + p.getNombre());
        this.presentarse("Bos días");
        p.presentarse("Ola");
    }
```

{% hint style="warning" %}
Habitualmente imonos referir a isto como **invocación/chamada a métodos**
{% endhint %}

### Abstracción

A abstracción vai a consistir en aislar un elemento do seu contexto, o que nos vai a permitir identificar as suas características e comportamento esencial, eliminando aqueles aspectos que non son relevantes para a resolución do problema que queremos modelar.

Volvendo ao exemplo anterior, as caracteristicas dunha persoa poden ser: Altura, peso, ADN, grupo sanguineo, nome, emocions, estudos, aficions, ....

{% hint style="warning" %}
Cando creamos a clase `Persona`, non estamos a representar unha persoa real con todo o seu detalle, senón unha **abstracción dunha persoa** adaptada ao problema que queremos resolver.

Por iso, **só incluímos aqueles atributos e métodos que son relevantes para o noso programa**, como o nome, o DNI ou a capacidade de falar con outra persoa, deixando fóra moitas outras características reais que non nos aportan nada.
{% endhint %}

### Encapsulación

O **encapsulamento** significa reunir datos e métodos relacionados nunha mesma clase e controlar o acceso a eles.

O **principio de ocultación**, moi relacionado co encapsulamento, indica que cada obxecto debe protexer o seu estado interno, evitando accesos directos aos seus atributos e permitindo que estes só se modifiquen de maneira controlada.

En Java a encapsulación vaise a xestionar mediante a visibilidade. O máis habitual é:

* Declarar os **atributos como privados**
* Proporcionar **métodos públicos** para acceder ou modificar eses datos

Este acceso mediante métodos permite que a **forma interna de almacenar os datos sexa responsabilidade exclusiva da clase**, sendo transparente para as demais clases que interactúan con ela.

Por exemplo, se eu quixese almacenar unha data nunha clase, na que teño a seguinte interface:

```java
public LocalDate getData(){
    ...
}

public void setData(LocalDate l){
    ...
}
```

Desde o exterior, unicamente coñecemos que o getData() devolve un LocalDate e o setData pide un LocalDate, pero **descoñecemos como se alamcena realmente a data internamente**. Podería:

* Gardar tres atributos (`ano`, `mes`, `día`)
* Gardar un obxecto `Date`
* Gardar un obxecto `LocalDate`
* Gardar calquera outra representación

Todo isto é **transparente para o resto das clases**, sempre que se manteña a mesma interface pública.

### Herdanza

A herdanza é un mecanismo da linguaxe que nos vai a permitir a creación de novas clases a partir de outras xa existentes. De maneira xeneral, imos atopar:

1. **Clases pai ou superclases**, nas que imos a definir atributos é métodos comúns
2. **Clases fillas ou subclases**, que van a herdar (ou redefinir) todas los métodos das clase pai, ademis de poder definir os seus propios métodos.

O emprego da **herdanza é unha caracteristica que vai a favorecer a abstración, encapsulación, a modularidade do código e a sua reutilización.**

```java
public class Peza {

    private String color;

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void mover(){
        System.out.println("Peza: Movemento non definido");
    }
}

public class Peon extends Peza {
    @Override
    public void mover() {
        System.out.println("Peon: Movo 1 espacio cara adianted forma xeral, que poden ser dous se é o primeiro movemento");
    }
}

public class App {

    public static void main(String[] args) {

        Peza p = new Peza();
        p.setColor("Blanco");
        p.mover();

        Peon peon = new Peon();
        peon.setColor("Negro");
        peon.mover();
    }
}

```

A clase Peón conta co atributo color da súa clase pai, cos seus getters e setters, e ademáis redefine o método mover.

### Polimorfismo

O concepto de polimorfismo implica que métodos co mesmo nome, poden estar suxeitos a comportamentos diferentes en función do obxecto que os execute. Seguindo con exemplo anterior, podemos observar que o método mover() implica unha saída diferente en función de que clase o execute:

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


---

# 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/caracteristicas-da-poo.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.