> 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/polimorfismo.md).
# Polimorfismo
O **polimorfismo** é unha característica da Programación Orientada a Obxectos que permite **enviar mensaxes sintacticamente iguais a obxectos distintos**, provocando **comportamentos diferentes** segundo o obxecto que reciba a mensaxe.
Noutras palabras, podemos chamar ao mesmo método do mesmo xeito, pero a acción que se executa dependerá do tipo concreto do obxecto.
En Java distinguimos **dous tipos de polimorfismo**:
## Polimorfismo en tempo de compilación (estático)
Este tipo de polimorfismo coñecese tamen como **sobrecarga.** Este polimorfismo se produce cando nunha mesma clase existen diferentes métodos que:
* Teñen o **mesmo nome**
* Teñen **distinto número ou tipo de parámetros**
O compilador decide **en tempo de compilación** que método debe executarse, en función da **sinatura do método** (nome + parámetros).
Este tipo de polimorfismo:
* Pódese aplicar a **métodos e construtores**
* É **menos flexible**
* Pero ofrece **maior rendemento**
```java
public class Calculadora {
public int sumar(int a, int b) {
return a + b;
}
public double sumar(double a, double b) {
return a + b;
}
public int sumar(int a, int b, int c) {
return a + b + c;
}
}
```
```java
sumar(2, 3); // chama ao método sumar(int, int)
sumar(2.5, 3.1); // chama ao método sumar(double, double)
sumar(1, 2, 3); // chama ao método sumar(int, int, int)
```
{% hint style="warning" %}
**A sobrecarga distingue entre nome de método e numero/tipo de parámetros, non inclue o tipo de retorno.** E dicir, non pode existir mais de un método co mesmo nome, mesmo número e tipo de parámetros e distinto tipo de retorno
```java
public class Calculadora {
public int sumar(int a, int b) {
return a + b;
}
public double sumar(double a, double b) {
return a + b;
}
public int sumar(int a, int b, int c) {
return a + b + c;
}
public float sumar(int a, int b){ //Erro de compilación, xa existe outro método
return 0.0; //coa mesma firma
}
}
```
{% endhint %}
### Sobrecarga de constructores
A sobrecarga ou polimorfismo estático funciona exactamente igual en métodos que en constructores, de feito, levamola empregando desde o inicio da unidade 3 sen mencionala expliciantemente. Neste caso, igual que cos métodos:
* O compilador decide **que construtor se chama**
* A decisión baséase **unicamente nos parámetros**
* Ocorre **antes de executar o programa**
```java
public class Usuario {
private String nome;
private int idade;
public Usuario() {
this("",0);
System.out.println("Construtor sen parámetros");
}
public Usuario(String nome) {
this(nome, 0);
System.out.println("Construtor con nome");
}
public Usuario(String nome, int idade) {
this.nome = nome;
this.idade = idade;
System.out.println("Construtor con nome e idade");
}
}
```
## Polimorfismo en tempo de execución (dinámico)
Este tipo de polimorfismo empregase habitualmente combinando tres elementos:
* Esta baseado na **herdanza** (ou uso de interfaces)
* Require a **sobreescritura de métodos**
* A decisión de que método se executa faise en tempo de execución
Unha **referencia dunha superclase** pode apuntar a obxectos de distintas clases fillas, e cando se chama a un método, execútase o método correspondente ao **tipo real do obxecto**, non ao tipo da referencia.
Nalgúns textos este tipo denomínase **polimorfismo de inclusión**.
```java
public class Mascota {
public void falar(){
System.out.println("A Mascota está falando");
}
public static void falarEstatico(){
System.out.println("A Mascota está falando en estático");
}
}
public class Can extends Mascota{
public void falar(){
System.out.println("O Can está falando");
}
public static void falarEstatico(){
System.out.println("O Can está falando en estático");
}
}
public static void main(String[] args) {
//Variable de tipo Superclase - Constructor de tipo Superclase
Mascota m = new Mascota();
//Variable de tipo Superclase - Constructor de tipo subclase
Mascota c = new Can();
System.out.println("Habla la mascota con constructor superclase");
m.falar();
System.out.println("Habla la mascota con constructor subclase");
c.falar();
}
```
{% hint style="warning" %}
**¡¡OLLO!! O polimorfismo dinámico non funciona con métodos de tipo estático**
{% endhint %}
```java
public static void main(String[] args) {
//Variable de tipo Superclase - Constructor de tipo Superclase
Mascota m = new Mascota();
//Variable de tipo Superclase - Constructor de tipo subclase
Mascota c = new Can();
System.out.println("Habla la mascota con constructor superclase");
m.falarEstatico();
System.out.println("Habla la mascota con constructor subclase");
c.falarEstatico();
}
```
---
# 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/polimorfismo.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.