From 6b25d6627b02681858d0bb232e757c31cea88525 Mon Sep 17 00:00:00 2001
From: Guadanhim <111758242+Guadanhim@users.noreply.github.com>
Date: Sun, 8 Oct 2023 06:32:27 -0300
Subject: [PATCH] polimorfismo

---
 POO/Polimorfismo/README.md                    | 44 +++++++++++++++++++
 .../exemplos/PolimorfismoSobrecarga.java      | 33 ++++++++++++++
 .../exemplos/PolimorfismoSobrescrita.Java     | 34 ++++++++++++++
 3 files changed, 111 insertions(+)
 create mode 100644 POO/Polimorfismo/README.md
 create mode 100644 POO/Polimorfismo/exemplos/PolimorfismoSobrecarga.java
 create mode 100644 POO/Polimorfismo/exemplos/PolimorfismoSobrescrita.Java

diff --git a/POO/Polimorfismo/README.md b/POO/Polimorfismo/README.md
new file mode 100644
index 0000000..fe8f1d2
--- /dev/null
+++ b/POO/Polimorfismo/README.md
@@ -0,0 +1,44 @@
+# Polimorfismo 
+
+## Um dos pilares da programação orientada a objetos (POO)
+
+Morfologicamente falando ao separar a palava temos _Poli_  que significa muitos, vários e _morfismo_ que está relacionado à forma. 
+Sendo assim _Polimorfismo_ que dizer "várias formas".
+
+O polimorfismo permite que objetos de classes diferentes respondam à mesma mensagem ou método de maneiras diferentes. Isso é possível porque objetos de tipos diferentes podem ter métodos com o mesmo nome, mas comportamentos diferentes.
+
+Portanto, o polimorfismo é uma característica importante da POO, pois torna o código mais versátil e flexível. Isso significa que você pode escrever código que funcione para objetos de várias classes diferentes, desde que essas classes implementem métodos com assinatura igual esperada.
+
+Podemos pontuar também o fato dele ser complementado pela _herança_ (um outro pilar da POO).
+
+E por se dividir em dois tipos principais: 
+- _Sobrecarga_.
+- _Sobrescrita_.
+
+### Sobrecarga
+
+A sobrecarga é a capacidade de uma classe ter dois ou mais métodos com o mesmo nome, mas com assinaturas diferentes. A assinatura de um método é composta pelo seu nome, tipo de retorno e lista de parâmetros.
+
+### Sobrescrita
+
+A sobrescrita é a capacidade de uma subclasse substituir o comportamento de um método herdado da superclasse. A sobrescrita requer que o método na subclasse tenha a mesma assinatura do método na superclasse.
+
+#### Diferenças entre os tipos: 
+| Característica | Sobrecarga | Sobrescrita |
+|---|---|---|
+| Definição | Capacidade de uma classe ter dois ou mais métodos com o mesmo nome, mas com assinaturas diferentes | Capacidade de uma subclasse substituir o comportamento de um método herdado da superclasse |
+| Assinatura | Diferente | Igual |
+| Tipo de retorno | Pode ser diferente | Deve ser o mesmo |
+| Lista de parâmetros | Pode ser diferente | Deve ser a mesma |
+| Modificadores | Qualquer | Não pode ser `final` ou `static` |
+
+
+## Referências
+
+ - [Java - Oracle ](https://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+
+ - [UFSC - Prof Frank Siqueira ](http://www.inf.ufsc.br/~frank.siqueira/INE5605/10.Polimorfismo.pdf)
+
+ - [UNESP - Prof Daniel Cardozo Mourao ](https://www.feg.unesp.br/Home/PaginasPessoais/profadanielacardozomourao/polimorfismo.pdf)
+
+ - [UFSM - Flash utilizando Orientação a Objetos e a linguagem XML. ](http://www-usr.inf.ufsm.br/~rose/curso3/cafe/cap4_Polimorfismo.pdf)
diff --git a/POO/Polimorfismo/exemplos/PolimorfismoSobrecarga.java b/POO/Polimorfismo/exemplos/PolimorfismoSobrecarga.java
new file mode 100644
index 0000000..4c66003
--- /dev/null
+++ b/POO/Polimorfismo/exemplos/PolimorfismoSobrecarga.java
@@ -0,0 +1,33 @@
+public class PolimorfismoSobrecarga {
+
+    // Método que aceita dois inteiros como argumentos
+    public int somar(int a, int b) {
+        return a + b;
+    }
+
+    // Método que aceita três inteiros como argumentos
+    public int somar(int a, int b, int c) {
+        return a + b + c;
+    }
+
+    // Método que aceita dois números de ponto flutuante como argumentos
+    public double somar(double a, double b) {
+        return a + b;
+    }
+
+    public static void main(String[] args) {
+        PolimorfismoSobrecarga calculadora = new PolimorfismoSobrecarga();
+
+        // Chamando o método de soma com dois inteiros
+        int resultado1 = calculadora.somar(5, 10);
+        System.out.println("Soma de inteiros: " + resultado1);
+
+        // Chamando o método de soma com três inteiros
+        int resultado2 = calculadora.somar(5, 10, 15);
+        System.out.println("Soma de três inteiros: " + resultado2);
+
+        // Chamando o método de soma com dois números de ponto flutuante
+        double resultado3 = calculadora.somar(3.5, 2.5);
+        System.out.println("Soma de números de ponto flutuante: " + resultado3);
+    }
+}
diff --git a/POO/Polimorfismo/exemplos/PolimorfismoSobrescrita.Java b/POO/Polimorfismo/exemplos/PolimorfismoSobrescrita.Java
new file mode 100644
index 0000000..3d973b5
--- /dev/null
+++ b/POO/Polimorfismo/exemplos/PolimorfismoSobrescrita.Java
@@ -0,0 +1,34 @@
+// Classe pai (superclasse)
+class Animal {
+    public void fazerSom() {
+        System.out.println("Animal faz algum som");
+    }
+}
+
+// Classe filha (subclasse)
+class Cachorro extends Animal {
+    @Override
+    public void fazerSom() {
+        System.out.println("Cachorro late");
+    }
+}
+
+// Outra classe filha (subclasse)
+class Gato extends Animal {
+    @Override
+    public void fazerSom() {
+        System.out.println("Gato mia");
+    }
+}
+
+public class PolimorfismoSobrescrita {
+    public static void main(String[] args) {
+        Animal meuAnimal;
+
+        meuAnimal = new Cachorro();
+        meuAnimal.fazerSom(); // Chama o método sobrescrito da classe Cachorro
+
+        meuAnimal = new Gato();
+        meuAnimal.fazerSom(); // Chama o método sobrescrito da classe Gato
+    }
+}
\ No newline at end of file