# Readme

## Princípios de Programação Orientada a Objetos

### Referência: Curso de Desenvolvimento Java, Giuliana Silva Bezerra

[Compre aqui](https://www.udemy.com/course/curso-de-desenvolvimento-java/)

***

### Tópicos

* [Pilares de POO](#pilares-de-poo)
* [Encapsulamento](#encapsulamento)
* [Modificador de Acesso - Atributos](#modificadores-de-acesso---atributos)
* [Modificador de Acesso - Método](#modificadores-de-acesso---métodos)
* [Modificador de Acesso - Classes](#modificadores-de-acesso---classes)
* [Gettes e Setters](#getters-e-setters)
* [Encapsulamento no Construtor](#encapsulamento-no-construtor)
* [Abstração](#abstração)
* [Herança](#herança)
* [Palavra Super](#palavra-super)
* [Sobrescrevendo Métodos](#sobrescrever-métodos)
* [Modificador Protected - Métodos](#modificador-protected---métodos)
* [Modificador Protected - Atributos](#modificador-protected---atributos)
* [InstanceOf](#instanceof)
* [Classe Object](#a-classe-object)
* [Classe Abstrata](#classes-abstratas)
* [Interface](#interface)
* [Método Default (Interface)](#método-default-interface)
* [Modificador Final](#modificador-final)
* [Polimorfismo](#polimorfismo)
* [Casting de Polimorfismo](#casting-de-polimorfismo)
* [Sobrecarga de Métodos](#sobrecarga-de-métodos)
* [Polimorfismo em Generics](#polimorfismo-em-generics)
* [Atributos no Polimorfismo](#atributos-no-polimorfismo)
* [Tipos de Polimorfismo - Compile vs Runtime](#tipo-de-polimorfismo---compile-vs-runtime)

***

## Pilares de POO

![img.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-49c7f9e273d088b0540c0d6b160fe918930c2286%2Fimg.png?alt=media)

Seguindo esses quatro pilares, será possivel obter um projeto orientado à objetos.

***

### Encapsulamento

Seu objetivo é esconder detalhes internos, expondo a interface facilitada do objeto. Por exemplo:

![img\_1.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-535c7666096614e320642c38ff1a739e21270b07%2Fimg_1.png?alt=media)

Imagine um carro. O motorista que é usuário do carro, ele pode interagir com o carro.

Mas ele interage somente com as interfaces disponíveis no carro (volante, pedais, o painel). Então, ele não precisa necessariamente saber como é o funcionamento do motor, dos airbags.. isso são detalhes ocultos, ou... **encapsulados**.

Não é bacana, portanto, deixarmos todos os objetos da nossa clase expostos. Ao fazermos isso, é possivel que o cliente não saiba/consiga usar o produto da forma correta (e até mesmo, segura).

O AirBag, por exemplo, não deve ser ativado pelo usuário quando bem quiser... e ainda entra os modificadores de acesso.

***

### Modificadores de Acesso - Atributos

Quais atributos fazem sentido ser publicos ou privados?

Foi o que falamos acima, volante e pedal é ok ser publico e acessado quando bem entender. Já o airbag e motor, não...

Para os visíveis (publicos), utilizamos: `public String volante`.

Para os privados (private), utilizamos: `private String airbag`.

O private permitirá acessar os atributos somente dentro da própria classe.

### Modificadores de Acesso - Métodos

Também podemos usar esses modificadores nos métodos.

Em suma, se quiser esconder um método é só declarar o modificador private!

***

### Getters e Setters

Dificilmente teremos atributos públicos. A maioria sempre será private e acessaremos os mesmos com Getters e Setters.

Eles nos permitem buscar o atributo em questão (get) e settar algum valor neles (setter).

***

### Modificadores de Acesso - Classes

As classes também podem ser modificadas. Porém só possuem 2 modificadores.

O public que é o padrão.

Mas também tem o “default”. Ou seja, vai ficar só `class Carro {}`.

***

### Encapsulamento no Construtor

O Construtor até pode ser private, o problema é que não será possivel instanciá-lo em outras classes.

Vale lembrar que o Construtor é onde inicializamos os atributos. Então é o local onde colocaremos os valores que desejarmos.

![img\_2.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-81c0a77f473492276b840bedfcf6b7b81f4466e7%2Fimg_2.png?alt=media)

***

### Abstração

Basicamente, seria esconder/exibir dados e comportamentos.

Isso é importante, pois é comum a gente esconder detalhes dos objetos, para facilitar seu uso. Uma TV, por exemplo, é muito complexa, quase ninguem sabe construir uma TV. Mas ela é entregue para você com uma interface simples de uso.

Para fazermos isso, basta criarmos métodos de utilização pro produto. No caso da TV, seria criar métodos de aumentarVolume, diminuirVolume, trocarCanal...

Ah, nesses métodos a gente sempre trabalha com o atributo, a gente vai usar o "this", para EVIDENCIAR que é o atributo da classe! Exemplo:

```java
public void trocarCanal(int novoCanal) {
    this.canal = novoCanal;
    // usando o this para referenciar ao atributo da classe, e trocando seu valor para o que
    // está no parâmetro.
}
```

***

### Herança

Seria o reuso. A ideia é evitarmos desperdício.

Ou seja, vamos centralizar a lógica em um lugar e torná-la acessível.

![img\_3.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-794d2e247de96d8ec8ba3658b6340ee38bb14f7f%2Fimg_3.png?alt=media)

Nós teremos uma classe pai (chamada de super classe), e ela irá possuir atributos e métodos a serem herdados por outras classes (classes filhas).

Vamos imaginar um exemplo de super-heróis. Em um pacote podemos ter uma classe: HomemAranha, Tempestade e HomemDeFerro.

Não é correto dentro do Main nós criarmos diversos métodos passando um super-heroi para cada um.

O correto, portanto, seria criar uma super classe denominada SuperHerói, contendo nela tudo o que um super-herói irá fazer.

Atributos padronizados, um método e até mesmo um construtor para iniciar um novo super-herói.

#### Beleza, a super classe foi criada. E pra aplicar ela a outras classes filha?

A gente simplesmente vai até a classe filha, HomemDeFerro, por exemplo, e usa a palavra **extends**.

Essa classe filha agora irá herdar e ser uma subclasse da outra. Vai herdar todos os atributos, métodos e construtores da superclasse.

***

### Palavra Super

Na classe filha, nós vamos criar um construtor (com a mesma quantidade de parametros) igual a superclasse.

Esse construtor vai ter um "super()" com os parametros ali dentro. Isso serve pra referenciar a superclasse (ao construtor dela).

***

### Sobrescrever Métodos

Se quisermos sobrescrever algo, basta reescrever o metodo na classe que desejamos!

***

### Modificador Protected - Atributos

Com os atributos private, não é possivel acessá-los nas classes filhas. Para que isso seja possível, utilizamos: protected.

***

### Modificador Protected - Métodos

Se utilizarmos o protected nos métodos da classe pai, somente quem está no pacote ou é subclasse, poderá usar. Na Main por exemplo, não será possível.

***

### InstanceOf

Imagine um cenário, onde a gente precise pegar esse Array de super herói e chamar algum método que irá ver se o super herói é suportado pelo jogo.

Criamos um método que retornará um void e passaremos como parametro um Array de SuperHeroi.

Mas e para validarmos esse parametro e conhecer o seu tipo? (se é um HomemAranha ou HomemDeFerro).

Para descobrirmos o tipo concreto de uma super classe, usaremos InstanceOf.

```java
static void validar(SuperHeroi[] superHerois) {
    //Verifica se o objeto super-heroi na posição 0 é uma instância do objeto HomemAranha
    if (superHerois[0] instanceof HomemAranha) {
        System.out.println("Lógica de validação do Homem Aranha");
    }
}
```

***

### A Classe Object

Tudo no java é Object, tudo mesmo, até mesmo classes. Todas elas herdam métodos, atributos e comportamentos do Object do java.

***

### Classes Abstratas

Se a classe SuperHeroi for abstrata, nós poderiamos ir no Main e criar simplesmente um:

```java
new SuperHeroi("meu traje", new String[] {"contar piada"});
```

Ou seja, uma instância de SuperHeroi sem definir um nome específico, nem nada do tipo. A partir do momento que definimos a classe pai como ‘Abstract’, não é mais possível criar uma instância da classe pai sem definir um nome a ela.

**Bom, mas os métodos dessa classe também podem ser abstratos.**

E isso significa que esse método ficará vazio! Sem corpo, sem definição, sem nenhum bloco de comando. Somente com o seu retorno e parâmetro, assim:

```java
public abstract void usarSuperPoder(int index);
```

**E o resultado disso?**

Bom, o que acontece, é que as classes, com esse método que se tornou abstrato implementado, vai precisar que a gente (de forma obrigatória), defina o seu corpo e os seus blocos de comando (o que de fato ele irá fazer).

Usaremos o @Override e implementaremos o que a gente quer.

***

### Interface

Uma classe abstrata pode ter atributos/metodos protected, atributos/métodos abstract.

Mas uma classe com Interface, é diferente! A gente só pode ter **definição de métodos.** Ela não terá atributos, nem definições de corpo de método.

Por exemplo, uma interface Avenger. O que a gente espera que uma classe que terá essa interface tenha?

Por fim, nos iremos à classe e implementaremos essa interface.

```java
public class HomemAranha extends SuperHeroi implements Avenger{}
```

**Não existe herança multipla (multiplos extends), mas podemos implementar diversas interfaces.**

Cabe destacar, que ao implementar uma interface a classe que deverá cumprir um "contrato". Ou seja, deverá implementar os métodos (que por padrão sao abstratos).

***

### Método Default (Interface)

A interface também pode ter um método chamado default. Todos as classes que terão essa interface implementarão ele.

Mas... não é o ideal usar isso. Quando a gente usa muito método default acaba que a gente transforma a interface numa classe e isso não é bacana.

***

### Modificador Final

O final impede que uma classe seja usada para herança, que alguem herde ela.

Isso ajuda a impedir o nosso codigo de ser utilizado para especificações ou modificações por outras pessoas. Ele será utilizada da forma que está.

Outro uso dele pode ser para criar constantes que não serão alteradas. Elas podem ser acessadas sim! Mas permanecerão iguais. É comum deixar essas constantes statics também.

Porque no fim vão ser sempre as mesmas, não é preciso instanciar elas.

**Por fim, sempre que declarmos um final, a gente precisa iniciar ele assim que o declaramos.**

***

### Polimorfismo

![img\_4.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-139df2cb9085f42442f6fd0d216dc68afe6fbed2%2Fimg_4.png?alt=media)

O verbo trabalhar, por exemplo. Todo trabalhador trabalha. Mas... e se for um programador? Qual o trabalho dele?

Ou seja, dependendo de onde o método for chamado, ele vai se comportar de forma diferente. Terá várias formas.

Cabe destacar que usamos o polimorfismo utilizando da herança. Isso tudo nos permite o reuso do código, proporcionando uma melhor usabilidade, etc.

Seguindo o exemplo de trabalho, criaremos uma interface Trabalhador.

![img\_5.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-faa969c50df253810f92ba415007efcf452f233a%2Fimg_5.png?alt=media)

E criaremos outras classes para implementar essa interface e cumprir esse "contrato". Essas classes podem ser: Médico, Cozinheiro, Programador..

E no Main ao invés de instanciarmos a clase criada, nós iremos referenciar a interface.

![img\_6.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-da95695c489de13fc0dcff64e1303efbadbfb9a7%2Fimg_6.png?alt=media)

E elas se comportarão de forma diferente, mesmo com a mesma funcionalidade em comum (ser da interface Trabalhador).

### Casting de Polimorfismo

Agora, uma única coisa. Como nós declaramos um cozinho por exemplo através da Interface, caso exista dentro da classe Cozinheiro outro método:

![img\_7.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-b49c75218cbd1629175737d50e2a9db6836bde17%2Fimg_7.png?alt=media)

A variável no Main não será apta a enxergar esse método criado. O que é específico da classe Cozinheiro só sera possível ver se intanciarmos ela.

Para isso, podemos usar um InstanceOf. No exemplo em questão, colocamos os 3 trabalhadores instanciados dentro de uma array:

![img\_8.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-9c7113249f04fc7e6d5b1e0260ea0e07cf3958fb%2Fimg_8.png?alt=media)

E faremos um método para percorrer esse array.

![img\_9.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-df42201b8b995a53434ffeb0010a47312a59f57d%2Fimg_9.png?alt=media)

E caso essa varíavel dentro do for seja uma InstanceOf Cozinheiro, aí sim poderá ser visualizado o método da classe.

***

### Sobrecarga de métodos

Imaginemos uma calculadora. Ao invés de termos métodos diferentes pra somar diferentes tipos de numero (double, int):

![img\_10.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-71605134a80f7f6ddceba4481d2c46c79ae8ec87%2Fimg_10.png?alt=media)

Nós podemos criar um método chamado soma somente, mas com retorno diferente:

![img\_11.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-6e631f1d2aec00a9180320d48674439530224135%2Fimg_11.png?alt=media)

E poderemos chamar o método normalmente passando parâmetros diferentes para cada operação.

![img\_12.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-ad4b14fa2426df29a7973f9a13974a09960ff8e1%2Fimg_12.png?alt=media)

***

### Polimorfismo em Generics

Nesse exemplo, criamos uma classe ImpressaoGenerics que irá possuir exatamente o que estava no Main (O array da Interface Trabalhador + o método de imprimir):

![img\_13.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-4875da5120afe2ad171bfa6722ee5e1f5f10d53d%2Fimg_13.png?alt=media)

Ok, e se quiséssemos usar o imprimir para imprimir outras coisas sem ser um array de Trabalhadores?

Bom, nesse caso o método imprimir irá retornar um tipo `<T>` e como parâmetro, tabém receberá o mesmo.

Tipo `<T>` é em suma, um tipo genérico.

![img\_14.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-963b884552770040d2a84a97d4b524ea4e8709c6%2Fimg_14.png?alt=media)

E assim, esse método será capaz de imprimir qualquer coisa.

***

### Atributos no Polimorfismo

**Em cima falamos de atributos em métodos, mas e nos atributos?**

Bom, aqui criamos uma classe Empregado que possui um atributo nome:

![img\_15.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-e3117e0c2840df086997c0ccd4ce159dfa3810ee%2Fimg_15.png?alt=media)

E exentederemos essa classe na Programador, mas atribuiremos um valor de "Programador":

![img\_16.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-bdb78191a24c9c26940b2cc8015491c9f76a00d4%2Fimg_16.png?alt=media)

Ao instanciarmos o Emprego e Programador chamando o ".nome", o que será exibido?

![img\_17.png](https://3013553905-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeOkFhgxwN0MpKNvntvmB%2Fuploads%2Fgit-blob-ffc15b3924b77bc9ad6e0c0c8e21641e2d9b0a82%2Fimg_17.png?alt=media)

Mas se o programador for instanciado como Empregado, será exibido "Empregado" ao invés de "Programador".

Por fim, para que a gente saiba o que será exibido, é só olharmos o tipo da variável. Sempre será a super classe que será exibida.

***

### Tipo de Polimorfismo - Compile vs Runtime

Compile - Tipo de compilação, estático. Vimos quando trabalhamos com sobrecarga de métodos (o exemplo da calculadora). O comportamento vai mudar em tempo de compilação, baseado nos argumentos que a gente passa no método.

Runtime - Tipo dinâmico. Ocorre quando a gente sobrescreve o método, conforme vimos no exemplo de [Atributos acima](#atributos-no-polimorfismo).
