Princípios de Programação Orientada a Objetos

index

Disclaimer

O conteúdo desse estudo foi feito durante o Curso de Desenvolvimento Java, lecionado pela Giuliana Silva Bezerra.

Aconselho veemente que você utilize este material como um complemento ao curso, e não como substituto do mesmo. A didática dela é incrível e você aprenderá muito mais seguindo o curso oficial.

Curso Oficial (Udemy) Canal Giu Bezerra

Pilares de Programação Orientada a Objetos (POO)

Temos quatro pilares essenciais na POO:

Encapsulamento: Agrupamento de dados e métodos que operam sobre esses dados numa única unidade (classe). Isso protege o estado interno do objeto, permitindo acesso controlado através de métodos públicos.
Abstração: Foco nos aspectos essenciais de um objeto, ignorando detalhes desnecessários. Isso simplifica a interação com objetos complexos, expondo apenas o que é relevante.
Herança: Mecanismo que permite criar classes baseadas em classes existentes, promovendo reutilização de código e estabelecimento de hierarquias entre classes.
Polimorfismo: Capacidade de objetos de diferentes classes responderem a mesma mensagem (método) de maneiras diferentes. Isso permite flexibilidade e extensibilidade no código.

Iremos agora, abordar cada um desses pilares com mais detalhes e exemplos práticos em Java.

1. Encapsulamento

O objetivo do encapsulamento é esconder detalhes internos de um objeto, expondo somente a interface do mesmo, exemplo:

Imaginemos um carro. O motorista é o usuário deste carro e com isso, ele pode interagir com o carro.

Entretanto, ele só interage com as interfaces disponíveis neste carro, como o volante, os pedais e o câmbio.

O motorista não precisa entender como o motor funciona para dirigir o carro, isso são detalhes ocultos, detalhes encapsulados.

Portanto, não é nada interessante que a gente deixe todos os objetos da nossa aplicação com atributos públicos e expostos, pois assim qualquer outro objeto poderia alterar o estado interno deste objeto, quebrando a lógica de negócio.

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 e métodos devem ser públicos, privados ou protegidos?

Conforme citamos assim, volante e pedal é ok ser público e acessado quando bem entender. Já o airbag e o motor, não.

Para os visíveis (públicos), podemos usar o modificador public -> public String volante.

Para os privados, usamos o modificador private -> private String motor.

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

Modificadores de Acesso - Métodos Getters e Setters

No geral, 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 ter modificadores de acesso. Podemos ter classes públicas e privadas.

Encapsulamento no Construtor da Classe

No construtor da classe, podemos definir quais atributos serão obrigatórios para criar um objeto daquela classe.

Nesse construtor, é onde inicializamos os atributos.

Ele pode até ser private, o problema é que isso impediria a criação de objetos fora da própria classe.

1
public Carro() {
2
    this.motor = new Motor(); // Inicializando o motor no construtor
3
    this.volante = "Volante";
4
    this.pedal = "Pedais";
5
}

2. Abstração

Em resumo, seria esconder e exibir dados e comportamentos.

Isso é extremamente importante, pois é comum o desenvolvedor esconder detalhes dos objetos, para facilitar o seu uso.

Uma TV, por exemplo: ela é muito complexa, quase ninguém sabe construir uma televisão, mas ela é entregue para você com uma interface simples, com poucos botões, para que você possa usá-la facilmente.

Para abstrair um objeto, basta criarmos métodos de utilização deste objeto. No caso da TV, seria por exemplo, criar métodos de aumentar e diminuir o volume, trocar de canal, ligar e desligar.

E nesses métodos, a gente sempre trabalha com os atributos privados do objeto, sem expor eles diretamente. Para isso, usamos o this, para EVIDENCIAR que é o atributo da classe, exemplo:

1
public class Tv {
2
    private int volume;
3
    private int canal;
4

5
    public void aumentarVolume() {
6
        this.volume++; // Aqui usamos o this para evidenciar que é o atributo da classe
7
    }
8

9
    public void diminuirVolume() {
10
        this.volume--;
11
    }
12

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

3. Herança

Herança seria o reuso de código. Podemos criar uma classe base, que terá atributos e métodos comuns a outras classes, evitando o desperdício de código.

Ou seja, nós centralizamos a lógica num lugar só, e as outras classes herdam essa lógica, tornando tudo mais acessível.

Basicamente nós teremos uma classe pai (superclasse) e uma classe filha (subclasse).

A classe pai terá atributos e métodos a serem herdados pelas classes filhas.

Vamos imaginar um exemplo de super-heróis. Em um pacote podemos ter várias classes:

HomemAranha
Tempestade
HomemDeFerro

Não é correto criarmos diversos métodos passando um super-herói como parâmetro. O correto seria criar uma superclasse chamada SuperHeroi, contendo nela tudo o que um super-herói tem em comum, como por exemplo, nome, poder, fraqueza e métodos como atacar() e defender().

Ok, e as classes filhas? Como aplicar isso?

Nós simplesmente vamos até a classe filha e usamos a palavra reservada extends, exemplo:

1
public class HomemAranha extends SuperHeroi {
2
    // A classe HomemAranha herda todos os atributos e métodos da classe SuperHeroi
3

4
    public HomemAranha() {
5
        super();
6
    }
7
}

Super

E esse super aí no construtor, o que é? Bom, o super() serve para chamar o construtor da superclasse (classe pai) e inicializar os atributos herdados.

Sobrescrita de Métodos

Além disso, dentro da classe filha, também podemos sobrepor métodos herdados da superclasse, exemplo:

1
@Override
2
public void atacar() {
3
    System.out.println("Homem-Aranha ataca com suas teias!");
4
}

Modificador Protected

Como os atributos da classe pai estão private, não conseguimos acessá-los diretamente na classe filha. Para isso, podemos usar protected ou criar métodos getters e setters na superclasse.

Se for optado por utilizar o protected, somente quem está no pacote ou é subclasse (classe filha) poderá acessar o atributo.

Lembre-se: tudo é objeto! Até mesmo classes, elas herdam métodos, atributos e comportamentos do Object do Java.

Classes Abstratas

Se a classe SuperHeroi fosse abstrata, não poderíamos criar objetos dela diretamente, exemplo:

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

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:

1
public abstract void usarSuperPoder(int index);

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/métodos protected e atributos/métodos abstract.

Mas uma classe com interface, é completamente 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?

1
public interface Avenger {
2
    void reunirVingadores();
3
    void salvarMundo();
4
}

E aí, qualquer classe que implementar essa interface, vai precisar obrigatoriamente implementar esses métodos.

1
public class HomemDeFerro implements Avenger {
2
    @Override
3
    public void reunirVingadores() {
4
        System.out.println("Homem de Ferro reunindo os Vingadores!");
5
    }
6
}

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.

4. Polimorfismo

Pensemos no verbo trabalhar. Todo trabalhador, independente da profissão, trabalha. Mas cada um trabalha de uma forma diferente.

Ou seja, dependendo de onde o método for chamado, ele vai se comportar de uma forma diferente.

Cabe destacar que o polimorfismo está muito ligado a herança. Isso tudo nos permite o conceito de “uma interface, múltiplas formas”.

Seguindo o exemplo de trabalho, criaremos uma interface Trabalhador, com o método trabalhar():

1
public interface Trabalhador {
2
    void trabalhar();
3
}

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

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

1
Trabalhador medico = new Medico();
2
Trabalhador cozinheiro = new Cozinheiro();
3
Trabalhador programador = new Programador();

E elas se comportarão de formas diferentes, mesmo sendo chamadas da mesma forma.

Casting de Polimorfismo

Às vezes, precisamos acessar métodos ou atributos específicos de uma classe filha, mesmo que a referência seja da superclasse ou interface.

Para isso, usamos o casting, que é basicamente “transformar” a referência de um tipo para outro.

1
Medico medicoEspecifico = (Medico) medico;
2
medicoEspecifico.realizarCirurgia();

Sobrecarga de Métodos

A sobrecarga de métodos é quando temos vários métodos com o mesmo nome, mas com diferentes listas de parâmetros (tipos ou quantidade).

1
public class Calculadora {
2
    public int somar(int a, int b) {
3
        return a + b;
4
    }
5
    public double somar(double a, double b) {
6
        return a + b;
7
    }
8
    public int somar(int a, int b, int c) {
9
        return a + b + c;
10
    }
11
}

Atributos no Polimorfismo

No polimorfismo, os atributos não são polimórficos. Ou seja, o tipo do atributo é determinado pela referência, não pelo objeto real.

Imagine a classe empregado que possui o atribute nome:

1
public class Empregado {
2
    public String nome = "Empregado Genérico";
3
}

Se extendermos essa classe na Programador, mas a referência for do tipo Empregado, o atributo acessado será o da classe Empregado, não o da classe Programador.

1
public class Programador extends Empregado {
2
    public String nome = "Programador Específico";
3
}

Ao instanciar os objetos:

1
Empregado emp = new Empregado();
2
System.out.println(emp.nome); // Saída: Empregado Genérico
3

4
Programador prog = new Programador();
5
System.out.println(prog.nome); // Saída: Programador Específico
6

7
Empregado prog = new Programador();
8
System.out.println(prog.nome); // Saída: Empregado Genérico