Guia Completo de Programação Orientada a Objetos (POO)

Conceitos Fundamentais

Classe e Objeto

// Classe - modelo/template
class Carro {
    String marca;
    String modelo;
    int ano;
    
    void acelerar() { }
    void frear() { }
}

// Objeto - instância da classe
Carro meuCarro = new Carro();
meuCarro.marca = "Toyota";

Atributos e Métodos

• Atributos: características/propriedades (variáveis)
• Métodos: comportamentos/ações (funções)
• Estado: valores atuais dos atributos
• Comportamento: implementação dos métodos

Pilares da POO

1. Encapsulamento

class ContaBancaria {
    private double saldo; // atributo privado
    
    public double getSaldo() { return saldo; } // getter
    public void setSaldo(double valor) { // setter
        if(valor >= 0) this.saldo = valor;
    }
}

• private: acesso apenas dentro da classe
• protected: acesso na classe e subclasses
• public: acesso irrestrito

Lembre-se: POO é sobre organizar código de forma mais natural, espelhando o mundo real através de classes e objetos!

2. Herança

// Classe pai (superclasse)
class Animal {
    String nome;
    void dormir() { }
}

// Classe filha (subclasse)
class Cachorro extends Animal {
    void latir() { } // método específico
}

• extends: palavra-chave para herança
• super: referencia a classe pai
• Herança simples vs múltipla

3. Polimorfismo

// Sobrescrita de método
class Animal {
    void emitirSom() { }
}

class Gato extends Animal {
    @Override
    void emitirSom() { System.out.println("Miau"); }
}

// Sobrecarga de método
class Calculadora {
    int somar(int a, int b) { return a + b; }
    double somar(double a, double b) { return a + b; }
}

4. Abstração

// Classe abstrata
abstract class Forma {
    abstract double calcularArea();
    void mostrarInfo() { } // método concreto
}

// Interface
interface Voador {
    void voar(); // método abstrato implícito
}

Construtores

class Pessoa {
    String nome;
    int idade;
    
    // Construtor padrão
    public Pessoa() { }
    
    // Construtor com parâmetros
    public Pessoa(String nome, int idade) {
        this.nome = nome;
        this.idade = idade;
    }
}

Modificadores de Acesso

Métodos e Atributos Estáticos

class MinhaClasse {
    static int contador = 0; // atributo estático
    
    static void incrementar() { // método estático
        contador++;
    }
}

// Uso sem criar objeto
MinhaClasse.contador++;
MinhaClasse.incrementar();

Interfaces vs Classes Abstratas

Interface

interface Transportavel {
    void transportar(); // público e abstrato
    default void parar() { } // método padrão (Java 8+)
}

Classe Abstrata

abstract class Veiculo {
    String marca; // pode ter atributos
    abstract void ligar(); // método abstrato
    void acelerar() { } // método concreto
}

Associação, Agregação e Composição

Associação

class Professor {
    List<Aluno> alunos; // conhece alunos
}

Agregação (HAS-A fraco)

class Departamento {
    List<Funcionario> funcionarios; // tem funcionários
}

Composição (HAS-A forte)

class Casa {
    List<Comodo> comodos; // comodos não existem sem casa
}

Principais Conceitos

• this: referência ao objeto atual
• super: referência à classe pai
• final: não pode ser modificado/herdado
• static: pertence à classe, não ao objeto
• abstract: não pode ser instanciado
• override: sobrescrita de método
• overload: sobrecarga de método

Tratamento de Exceções

try {
    // código que pode gerar exceção
} catch (Exception e) {
    // tratamento da exceção
} finally {
    // sempre executa
}

Dicas

1. Identifique o tipo de relacionamento: IS-A (herança) vs HAS-A (composição/agregação)
2. Visibilidade: private < default < protected < public
3. Polimorfismo: mesmo método, comportamentos diferentes
4. Construtores: sempre executam na criação do objeto
5. Métodos estáticos: chamados pela classe, não pelo objeto
6. Interfaces: contrato que deve ser implementado
7. Classes abstratas: não podem ser instanciadas
8. Encapsulamento: use getters/setters para atributos privados

Padrões Comuns

Singleton

class Singleton {
    private static Singleton instancia;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if(instancia == null) {
            instancia = new Singleton();
        }
        return instancia;
    }
}

Factory

class AnimalFactory {
    static Animal criarAnimal(String tipo) {
        if("dog".equals(tipo)) return new Cachorro();
        if("cat".equals(tipo)) return new Gato();
        return null;
    }
}

Conceitos Extras

Palavras-chave importantes

• instanceof: verifica se objeto é instância de uma classe
• package: organiza classes em namespaces
• import: importa classes de outros pacotes

Tipos de classes

• Classe concreta: pode ser instanciada
• Classe abstrata: não pode ser instanciada
• Classe final: não pode ser herdada
• Classe interna: definida dentro de outra classe

Relacionamentos

• IS-A: herança (Cachorro IS-A Animal)
• HAS-A: composição/agregação (Carro HAS-A Motor)
• USES-A: dependência (Cliente USES-A Produto)