# POO ### Desvendando a Orientação a Objetos em Java: Guia Prático com Exemplos Vamos desmistificar os quatro pilares da POO em Java com exemplos práticos e diretos ao ponto. Vamos lá? #### O que é Programação Orientada a Objetos? Em poucas palavras, a POO é um modelo de programação que utiliza "objetos" para representar coisas e conceitos. Pense em um carro: ele tem características (cor, marca, ano) e comportamentos (acelerar, frear, buzinar). Na POO, as características são os **atributos** e os comportamentos são os **métodos**. Tudo isso é agrupado em uma "planta" chamada **classe**. *** #### 🔐 Encapsulamento: Protegendo Seus Dados O encapsulamento é o princípio de esconder os detalhes internos de um objeto e expor apenas o necessário. Isso protege os dados de modificações acidentais e mantém o código organizado. Em Java, usamos modificadores de acesso como `private` para os atributos e métodos públicos (`public`), conhecidos como *getters* e *setters*, para interagir com eles. **Exemplo Prático:** Vamos criar uma classe `ContaBancaria`. O saldo (`saldo`) deve ser privado para que ninguém possa alterá-lo diretamente sem passar por uma verificação. Java ```java public class ContaBancaria { private double saldo; public ContaBancaria(double saldoInicial) { this.saldo = saldoInicial; } // Getter para obter o saldo public double getSaldo() { return saldo; } // Método público para depositar de forma segura public void depositar(double valor) { if (valor > 0) { this.saldo += valor; System.out.println("Depósito de R$" + valor + " realizado com sucesso."); } else { System.out.println("Valor de depósito inválido."); } } // Método público para sacar public void sacar(double valor) { if (valor > 0 && valor <= this.saldo) { this.saldo -= valor; System.out.println("Saque de R$" + valor + " realizado com sucesso."); } else { System.out.println("Saldo insuficiente ou valor inválido."); } } } ``` **Como usar:** Java ```java ContaBancaria minhaConta = new ContaBancaria(1000.0); // System.out.println(minhaConta.saldo); // Erro! O atributo é privado. System.out.println("Saldo atual: R$" + minhaConta.getSaldo()); // Jeito certo minhaConta.depositar(500.0); minhaConta.sacar(200.0); System.out.println("Saldo final: R$" + minhaConta.getSaldo()); ``` *** #### 🎭 Polimorfismo: Muitas Formas, Uma Ação Polimorfismo (do grego, "muitas formas") é a capacidade de um objeto ser referenciado de múltiplas maneiras. Em Java, isso geralmente acontece com a **sobreposição de métodos** (*overriding*). Uma classe filha pode ter uma implementação específica para um método que já existe em sua classe mãe. **Exemplo Prático:** Imagine que temos uma classe `Animal` com um método `fazerSom()`. Cães e gatos fazem sons, mas de maneiras diferentes. Java ```java // Classe mãe class Animal { public void fazerSom() { System.out.println("O animal faz um som"); } } // Classes filhas class Cachorro extends Animal { @Override // Sobrescrevendo o método public void fazerSom() { System.out.println("O cachorro late: Au au!"); } } class Gato extends Animal { @Override // Sobrescrevendo o método public void fazerSom() { System.out.println("O gato mia: Miau!"); } } ``` **Como usar:** O poder do polimorfismo brilha aqui. Podemos tratar tanto `Cachorro` quanto `Gato` como se fossem simplesmente `Animal`. Java ```java Animal meuCachorro = new Cachorro(); Animal meuGato = new Gato(); meuCachorro.fazerSom(); // Saída: O cachorro late: Au au! meuGato.fazerSom(); // Saída: O gato mia: Miau! ``` *** #### blueprint Classe Abstrata: O Esqueleto do Negócio Uma classe abstrata é como um modelo semi-pronto. Ela pode ter tanto métodos concretos (com implementação) quanto métodos abstratos (sem implementação). Classes que herdam de uma classe abstrata são **obrigadas** a implementar os métodos abstratos. **Quando usar?** Use uma classe abstrata quando você tem um conjunto de classes que compartilham uma estrutura e comportamento comuns, mas alguns detalhes de implementação são específicos para cada uma. **Exemplo Prático:** Pense em um `Veiculo`. Todo veículo tem um motor que pode ser ligado (comportamento comum), mas a forma como ele se move pode variar (carro acelera, barco navega). Java ```java // Classe abstrata abstract class Veiculo { private String marca; // Construtor public Veiculo(String marca) { this.marca = marca; } // Método concreto (compartilhado por todos os filhos) public void ligar() { System.out.println("O veículo " + marca + " ligou o motor."); } // Método abstrato (deve ser implementado pelos filhos) public abstract void mover(); public String getMarca() { return marca; } } class Carro extends Veiculo { public Carro(String marca) { super(marca); } @Override public void mover() { System.out.println("O carro " + getMarca() + " está acelerando na estrada."); } } ``` **Como usar:** Java ```java // Veiculo meuVeiculo = new Veiculo("Genérico"); // Erro! Não se pode instanciar classe abstrata. Carro meuCarro = new Carro("Fiat"); meuCarro.ligar(); meuCarro.mover(); ``` *** #### 📜 Interface: O Contrato de Funcionalidades Uma interface é um "contrato" que define um conjunto de métodos que uma classe deve implementar. Ela não contém nenhuma implementação, apenas as assinaturas dos métodos. Uma classe pode implementar múltiplas interfaces, o que resolve a limitação do Java de só poder herdar de uma única classe. **Quando usar?** Use uma interface quando quiser definir um "papel" ou uma "capacidade" que diferentes classes podem ter, mesmo que não tenham uma relação de herança direta. Ex: "ser serializável", "ser clicável", "ser voável". **Exemplo Prático:** Vamos definir a capacidade de `Voar`. Tanto um `Passaro` quanto um `Aviao` podem voar, mas são entidades completamente diferentes. Java ```java // A interface define o "o quê", não o "como" interface Voavel { void decolar(); void voar(); void aterrissar(); } class Aviao implements Voavel { @Override public void decolar() { System.out.println("Avião decolando da pista..."); } @Override public void voar() { System.out.println("Avião voando em altitude de cruzeiro."); } @Override public void aterrissar() { System.out.println("Avião aterrissando na pista."); } } class Passaro implements Voavel { @Override public void decolar() { System.out.println("Pássaro levanta voo do galho."); } @Override public void voar() { System.out.println("Pássaro batendo asas pelo céu."); } @Override public void aterrissar() { System.out.println("Pássaro pousa em um fio."); } } ``` **Como usar:** Java ```java Voavel meuAviao = new Aviao(); Voavel meuPassaro = new Passaro(); meuAviao.voar(); // Saída: Avião voando em altitude de cruzeiro. meuPassaro.voar(); // Saída: Pássaro batendo asas pelo céu. ``` #### Conclusão Dominar a Orientação a Objetos é um passo fundamental para escrever códigos mais limpos, flexíveis e escaláveis em Java. * **Encapsulamento** protege seus dados. * **Polimorfismo** permite que seu código seja mais flexível. * **Classes Abstratas** criam um esqueleto para classes relacionadas. * **Interfaces** definem contratos ou habilidades que classes não relacionadas podem implementar
{% embed url="" %} {% file src="" %}