POO com Java

Cartões · 50

Classe

Usado como molde para criar objetos. Java: public class Carro {}. Python: class Carro:. Java exige declaração formal de tipos e arquivos com o mesmo nome da classe pública.

Objeto e Instanciação

Usado para materializar a classe na memória. Java: Carro c = new Carro(); (exige new e tipo). Python: c = Carro() (sem new, tipagem dinâmica).

Atributos de Instância

Usado para guardar o estado do objeto. Java: declarados no corpo da classe (String cor;). Python: definidos dinamicamente dentro do construtor usando self (self.cor = cor).

Métodos de Instância

Usado para definir ações do objeto. Java: void acelerar() {}. Python: def acelerar(self): pass. Em Python o primeiro parâmetro explícito é sempre self.

Construtor Padrão

Usado para inicializar objetos na criação. Java: public Carro() {} (mesmo nome da classe). Python: def __init__(self): (método mágico com dois underlines).

Construtor com Parâmetros

Usado para injetar dependências ou valores iniciais. Java: public Carro(String m) { this.m = m; }. Python: def __init__(self, m): self.m = m. Java usa this e Python usa self.

Palavra-chave this vs self

Usado para referenciar a própria instância. Java: this é implícito nos parâmetros de métodos. Python: self deve ser explicitamente declarado como primeiro argumento do método.

Encapsulamento: Modificador private

Usado para restringir acesso direto a atributos. Java: private int saldo; (bloqueio rígido pelo compilador). Python: _saldo (convenção) ou __saldo (name mangling, sem bloqueio real).

Encapsulamento: Modificador public

Usado para expor métodos e classes globalmente. Java: public void exibir() {}. Python: padrão para qualquer atributo ou método sem underlines na frente.

Getters e Setters

Usado para leitura e escrita controlada de atributos privados. Java: getNome() e setNome(String n). Python: convenção usa decoradores @property e @nome.setter.

Herança Simples

Usado para reaproveitar e estender lógica de uma classe base. Java: class Gato extends Animal {}. Python: class Gato(Animal):. Java usa a palavra extends.

Herança Múltipla de Classes

Usado para herdar de mais de uma classe base. Java: proibido para classes, permitido apenas com múltiplas interfaces. Python: nativamente permitido (class C(A, B):).

Chamada à Superclasse (super)

Usado para invocar construtores ou métodos da classe pai. Java: super(nome); ou super.falar();. Python: super().__init__(nome) ou super().falar().

Sobrescrita de Métodos (Override)

Usado para redefinir o comportamento herdado da classe mãe. Java: anotação opcional @Override void som() {}. Python: apenas redefine def som(self): com o mesmo nome.

Sobrecarga de Métodos (Overload)

Usado para ter métodos com mesmo nome e assinaturas diferentes. Java: suportado nativamente (void som(), void som(int vol)). Python: não suportado nativamente, usa argumentos padrão (*args).

Polimorfismo em Tempo de Execução

Usado para tratar objetos filhos como tipo genérico pai. Java: Animal a = new Cachorro(); a.som();. Python: Duck Typing (se anda e grasna como pato, é tratado como pato).

Classe Abstrata

Usado como molde incompleto que não pode ser instanciado diretamente. Java: abstract class Animal {}. Python: requer herdar de abc.ABC (class Animal(ABC):).

Método Abstrato

Usado para forçar subclasses a implementarem o método. Java: abstract void emitirSom();. Python: requer decorador @abstractmethod def emitir_som(self): pass.

Interface

Usado para definir contratos e comportamentos desacoplados. Java: interface Autenticavel { void login(); }. Python: não possui interfaces nativas, usa classes base abstratas ou protocolos.

Implementação de Interface

Usado para assinar um contrato comportamental. Java: class Usuario implements Autenticavel {}. Python: classe herda da classe abstrata correspondente.

Múltiplas Interfaces

Usado para assinar vários contratos na mesma classe. Java: class Robo implements Andador, Falador {}. Python: herança múltipla simples class Robo(Andador, Falador):.

Atributo Estático (Classe)

Usado para dados compartilhados entre todas as instâncias. Java: static int contador = 0;. Python: variável declarada no escopo da classe (contador = 0).

Método Estático

Usado para utilitários independentes de estado de objeto. Java: static int somar(int a, int b) {}. Python: requer decorador @staticmethod def somar(a, b):.

Método de Classe

Usado para acessar ou alterar o estado da classe, não da instância. Java: métodos estáticos acessam atributos static diretamente. Python: usa decorador @classmethod def criar(cls):.

Constantes (final)

Usado para criar valores imutáveis. Java: public static final double PI = 3.14;. Python: convenção em maiúsculas (PI = 3.14), mas o valor pode ser alterado em runtime.

Classes Imutáveis (Records)

Usado para DTOs e classes focadas puramente em dados imutáveis. Java: record Ponto(int x, int y) {}. Python: usa decorador @dataclass(frozen=True) class Ponto:.

Comparação de Igualdade de Objetos

Usado para verificar igualdade lógica entre instâncias. Java: obj1.equals(obj2) (== compara ponteiros). Python: obj1 == obj2 invoca __eq__, enquanto is compara ponteiros.

Representação em String

Usado para converter o objeto em texto amigável para debug/log. Java: sobrescrever public String toString() {}. Python: sobrescrever os métodos mágicos __str__ e __repr__.

Modificador protected

Usado para permitir acesso à subclasse e pacote. Java: protected int idade; acessível no mesmo pacote e subclasses. Python: convenção de underline simples (_idade), sem restrição real.

Modificador Package-Private (Default)

Usado para encapsulamento restrito ao pacote de classes irmãs. Java: sem palavra-chave (int v;). Python: não possui conceito de escopo de pacote ou visibilidade default.

Tratamento de Exceções em POO

Usado para lidar com erros em operações de objetos. Java: try { ... } catch(Exception e) { ... } (exceções checadas e não-checadas). Python: try: ... except Exception as e:.

Criação de Exceção Customizada

Usado para representar erros de domínio na aplicação. Java: class SaldoException extends Exception {}. Python: class SaldoError(Exception): pass.

Composição de Objetos

Usado para expressar relação de posse ('tem um') em vez de herança. Java: class Carro { private Motor motor = new Motor(); }. Python: class Carro: def __init__(self): self.motor = Motor().

Agregação

Usado para vincular objetos independentes em ciclo de vida. Java: class Time { private List<Atleta> atletas; }. Python: class Time: def __init__(self, atletas): self.atletas = atletas.

Classes Internas (Inner Classes)

Usado para agrupar logicamente classes auxiliares. Java: class Externa { class Interna {} } com acesso ao outer this. Python: class Externa: class Interna: pass, apenas namespace.

Classes Anônimas

Usado para instanciar e implementar interfaces pontuais inline. Java: Runnable r = new Runnable() { public void run() {} };. Python: não existem classes anônimas, usa funções lambda ou defs.

Expressões Lambda em POO

Usado para implementar interfaces funcionais de forma concisa. Java: Runnable r = () -> System.out.println();. Python: fn = lambda x: x * 2, limitado a uma única expressão.

Interfaces Funcionais

Usado para tipar funções de ordem superior com POO. Java: @FunctionalInterface interface Operacao { int calcular(int a); }. Python: usa tipos de typing.Callable sem interfaces.

Genéricos (Generics) em Classes

Usado para parametrizar tipos garantindo segurança em tempo de compilação. Java: class Caixa<T> { T item; }. Python: type hints opcionais com class Caixa(Generic[T]):.

Genéricos com Delimitação (Bounded Generics)

Usado para restringir tipos a uma hierarquia específica. Java: class Repo<T extends Model> {}. Python: TypeVar com restrição: T = TypeVar('T', bound=Model).

Type Casting e Checagem de Tipo

Usado para inspecionar e converter tipos da hierarquia. Java: if (obj instanceof Carro c) (pattern matching). Python: if isinstance(obj, Carro): c = obj (sem cast formal).

Método Final

Usado para impedir que subclasses sobrescrevam a implementação. Java: public final void travar() {}. Python: decorador typing.final apenas para linters, não imposto em runtime.

Classe Final

Usado para impedir que a classe seja herdada. Java: public final class Imutavel {}. Python: decorador @typing.final, o interpretador permite herança mesmo assim.

Enums em POO

Usado para representar conjuntos fixos de constantes com métodos. Java: enum Status { ATIVO, INATIVO; void run(){} }. Python: herda de enum.Enum (class Status(Enum): ATIVO = 1).

Destrutores e Coleta de Lixo

Usado para liberar recursos associados ao ciclo de vida do objeto. Java: Garbage Collector automático (finalize() descontinuado). Python: método mágico __del__(self) acionado por contagem de referências.

Gerenciamento de Recursos: try-with-resources

Usado para fechar conexões/arquivos automaticamente. Java: try (Scanner s = new Scanner()) {} (AutoCloseable). Python: context manager com bloco with open() as f: (__enter__/__exit__).

Métodos Padrão em Interfaces (default methods)

Usado para evoluir interfaces sem quebrar implementações existentes. Java: default void log() { System.out.println(); }. Python: herança múltipla de classes base comuns resolve isso.

Sobrecarga de Operadores

Usado para customizar o comportamento de operadores (+, -, *) em classes. Java: não suportado pela linguagem. Python: nativamente suportado via métodos mágicos (__add__, __sub__).

Módulos vs Pacotes

Usado para organizar o código em namespaces e diretórios. Java: package com.app; no topo do arquivo que reflete diretórios. Python: cada arquivo .py é um módulo; pastas com __init__.py são pacotes.

Padrão Singleton

Usado para garantir uma única instância de uma classe no sistema. Java: construtor private e método static getInstance(). Python: pode ser feito em __new__ ou criando simplesmente um módulo dedicado.