PDF para estudo próprio sobre POO.

POLIMORFISMO
O polimorfismo é implementado através do uso de herança e interfaces. Ele
permite que o desenvolvedor escreva um código mais flexível, reutilizável e
fácil de manter.
Polimorfismo significa "muitas formas", que permite ao desenvolvedor usar o
mesmo elemento de formas diferentes.
No Polimorfismo temos dois tipos:

+ Polimorfismo Estático ou Sobrecarga

+ Polimorfismo Dinâmico ou Sobreposição

Polimorfismo Estático ou Sobrecarga

Ele permite que você defina múltiplos métodos com o mesmo nome em uma
classe, mas com diferentes parâmetros.
A sobrecarga ocorre quando você tem vários métodos com o mesmo nome em
uma classe, mas cada método possui uma assinatura diferente. A assinatura de
um método é composta pelo nome do método e pelos tipos e ordem dos
parâmetros.
Neste exemplo, temos a classe Calculadora com três métodos somar, todos
eles possuindo o mesmo nome, mas com diferentes tipos de parâmetros.

Ao chamar o método, o compilador decidirá qual versão do método usar com

base nos argumentos passados. Por exemplo:

No exemplo acima, a sobrecarga de métodos permite que o mesmo nome

somar seja usado para diferentes tipos de parâmetros. O compilador
selecionará automaticamente a versão correta do método com base nos
argumentos passados. É importante destacar que o polimorfismo estático
ocorre em tempo de compilação, pois o compilador decide qual método
sobrecarregado será chamado com base nos tipos estáticos dos argumentos.

Polimorfismo Dinâmico ou Sobreposição

polimorfismo dinâmico diferente do estático, ocorre em tempo de execução e
está relacionado à hierarquia de classes e à herança.
O polimorfismo dinâmico permite que uma classe filha substitua um método
definido em sua classe pai, fornecendo uma implementação específica para
aquele método. Isso significa que você pode ter o mesmo método em uma
classe pai e em suas classes filhas, mas cada classe filha pode ter uma
implementação diferente para esse método.
Exemplo a seguir:
Nesse exemplo, temos uma classe Animal com um método emitirSom(). As
classes Cachorro e Gato são subclasses da classe Animal e substituem
(sobrepõem) o método emitirSom() com suas próprias implementações.
Ao chamar o método emitirSom(), o comportamento do método será
determinado pelo tipo de objeto em tempo de execução. Por exemplo:
Nesse caso, mesmo que as variáveis animal, cachorro e gato sejam todas do
tipo Animal, o polimorfismo dinâmico permite que o método emitirSom() de
cada objeto seja executado de acordo com a implementação da classe
específica em tempo de execução. Isso é possível porque o método foi
substituído nas classes filhas.
Em resumo, o polimorfismo dinâmico ou sobreposição de métodos permite que
uma classe filha substitua um método da classe pai com sua própria
implementação. Isso oferece flexibilidade e extensibilidade em relação ao
comportamento dos objetos em tempo de execução, possibilitando a execução
do método correto com base no tipo de objeto em tempo de execução.

FUNÇÕES
As funções são chamadas de métodos. Os métodos são blocos de código que
são definidos dentro de uma classe e podem ser invocados para executar
ações específicas em objetos dessa classe.
Esses exemplos abaixo, são apenas exemplos básicos para ilustrar o conceito
de métodos em POO. Na prática, os métodos podem ter uma ampla variedade
de funcionalidades, desde simplesmente retornar valores até realizar
operações complexas e interagir com outros objetos.
Aqui vai um resumo dos principais pontos sobre métodos em POO que são
(Definição de métodos, Invocação de métodos, Passagem de parâmetros,
Retorno de valores, com exemplos:

Definição de métodos:
Neste código, temos uma classe chamada Exemplo. Dentro dessa classe,
definimos dois métodos: metodoSemRetorno e metodoComRetorno.

O método metodoSemRetorno não possui parâmetros e nem retorno (void). Ele

é usado para realizar uma determinada lógica, mas não retorna um valor
específico. Você pode inserir qualquer lógica dentro desse método,
dependendo do que precisa ser feito.

O método metodoComRetorno recebe dois parâmetros do tipo inteiro (int a e int

b). Ele realiza a soma desses dois valores e armazena o resultado na variável
resultado. Em seguida, o método retorna esse resultado como um valor do tipo
inteiro.

Primeiro, criamos uma instância da classe Exemplo chamada objeto. Em

seguida, chamamos o método metodoSemRetorno() desse objeto. Essa
chamada executará a lógica definida no método metodoSemRetorno.

Depois, chamamos o método metodoComRetorno(2, 3). Passamos os valores

2 e 3 como argumentos para o método. Dentro do método, esses valores são
somados, resultando em 5. O método retorna esse valor, que é armazenado na
variável resultado.
Classe Filha & Classe Pai

uma classe filha, também chamada de classe derivada ou subclasse, é uma

classe que herda características (atributos e métodos) de outra classe,
chamada de classe pai, classe base ou superclasse.
A relação entre uma classe filha e uma classe pai é estabelecida por meio do
conceito de herança. A herança permite que uma classe filha herde os
membros (atributos e métodos) da classe pai e também adicione seus próprios
membros exclusivos.
A classe filha pode estender a funcionalidade da classe pai, adicionando novos
comportamentos específicos ou sobrescrevendo os comportamentos
existentes. Essa é uma forma de reutilização de código, pois evita a duplicação
de código em várias classes.
Aqui está um exemplo simplificado para ilustrar a relação entre uma classe filha
e uma classe pai em Java:
HERENÇA

A herança é um conceito fundamental em POO, que permite criar novas

classes baseadas em classes existentes. É um mecanismo de reutilização de
código que promove a extensibilidade, especialização e organização
hierárquica das classes.
Na herança, uma classe chamada classe filha ou classe derivada herda
características (atributos e métodos) de outra classe chamada classe pai,
classe base ou superclasse. A classe filha herda todos os membros da classe
pai, exceto aqueles que são declarados como privados.
A herança é representada visualmente usando uma estrutura de árvore
chamada hierarquia de classes, onde a classe pai está no nível superior e as
classes filhas estão nos níveis subsequentes. A classe filha pode adicionar
seus próprios membros exclusivos, além de herdar os membros da classe pai.

Neste exemplo, a classe Cachorro herda da classe Animal. Isso significa que a
classe Cachorro terá todos os atributos e métodos definidos na classe Animal,
além de poder adicionar seus próprios atributos e métodos exclusivos.
A herança permite vários benefícios na programação orientada a objetos:
Reutilização de código: A herança permite que você reutilize o código da
classe pai na classe filha, evitando a duplicação de código e promovendo a
organização e a manutenção do código.
Extensibilidade: A classe filha pode adicionar novos membros ou
comportamentos à classe pai, estendendo suas funcionalidades. Isso permite
que você crie classes mais especializadas e adaptadas às necessidades
específicas.
Polimorfismo: O polimorfismo é outro conceito importante em POO que é
viabilizado pela herança. Ele permite que um objeto de uma classe filha seja
tratado como um objeto da classe pai, permitindo substituições e execução
dinâmica de métodos.
Organização hierárquica: A herança permite organizar as classes em uma
hierarquia, representando as relações de especialização e generalização entre
elas. Isso ajuda na compreensão do design do sistema e facilita a manutenção
do código.

Em resumo, a herança em POO é um mecanismo que permite que as classes

filhas herdem características da classe pai. Ela promove a reutilização de
código, extensibilidade e organização hierárquica das classes. A herança é
representada usando a palavra-chave extends na declaração da classe filha.

ABSTRAÇÃO:
A abstração é um conceito fundamental na programação orientada a objetos.
Ela envolve a simplificação e a modelagem de objetos do mundo real em
classes e objetos mais genéricos, identificando as características essenciais e
os comportamentos relevantes para o sistema em questão. A ideia é capturar
apenas as informações relevantes e ocultar os detalhes irrelevantes.
Na prática, a abstração é alcançada por meio da definição de classes abstratas
ou interfaces que estabelecem um contrato com as subclasses. Essas classes
abstratas fornecem uma visão simplificada dos objetos, descrevendo apenas
os atributos e métodos essenciais.

EXEMPLO DE ABSTRAÇÃO:
Suponha que estamos criando um sistema de gerenciamento de animais de um
zoológico. Podemos definir uma classe abstrata chamada "Animal" com
métodos como "mover()" e "emitirSom()". Esses métodos são abstratos, o que
significa que eles não têm implementação na classe abstrata. Em vez disso, as
subclasses concretas, como "Cachorro", "Gato" e "Elefante", devem
implementar esses métodos de acordo com suas características específicas. A
classe "Animal" fornece uma abstração que encapsula o comportamento
comum a todos os animais, sem se preocupar com as especificidades de cada
animal individual.
Nesse exemplo, a classe abstrata "Animal" define um método abstrato "emitirSom()",
que todas as subclasses concretas devem implementar. As subclasses "Cachorro" e
"Gato" estendem a classe abstrata "Animal" e fornecem suas próprias implementações
do método "emitirSom()". No código principal, podemos criar objetos das subclasses e
chamá-los para emitir seus respectivos sons.
ENCAPSULAMENTO:
O encapsulamento é um princípio da programação orientada a objetos que visa
proteger os dados e ocultar os detalhes internos de uma classe, fornecendo
interfaces controladas para acessá-los. Isso é feito definindo atributos como
privados e fornecendo métodos públicos (getters e setters) para acessar e
modificar esses atributos.
O encapsulamento permite que uma classe controle como seus dados são
manipulados e evita que outros objetos acessem e modifiquem diretamente
seus atributos internos. Isso promove uma melhor organização do código,
facilita a manutenção e possibilita a validação e aplicação de regras específicas
antes de alterar os dados.

Exemplo de Encapsulamento:
Considere a classe "Pessoa" com o atributo "nome". Podemos encapsular esse
atributo, tornando-o privado e fornecendo métodos públicos para acessá-lo e
modificá-lo, como "getNome()" e "setNome()". Dessa forma, o acesso direto ao
atributo "nome" é impedido, e qualquer manipulação desse valor precisa ser
feita por meio dos métodos fornecidos.

Nesse exemplo, o encapsulamento garante que o atributo "nome" só possa ser

acessado e modificado pelos métodos getNome() e setNome(). Isso permite
que a classe controle como o nome é alterado e adicione validações ou lógicas
extras, se necessário.