Programação Orientada a Objetos

Cartões · 50

Classe

class Carro: pass. Molde ou estrutura básica que define atributos e comportamentos comuns a todos os objetos criados a partir dela.

Objeto

meu_carro = Carro(). Instância concreta de uma classe que ocupa espaço na memória e possui seu próprio estado.

Atributo de Instância

self.cor = 'azul'. Variável vinculada a um objeto específico, armazenando dados que caracterizam essa instância.

Atributo de Classe

class Carro: rodas = 4. Variável compartilhada por todas as instâncias da classe, cujo valor é comum a todos os objetos.

Método de Instância

def acelerar(self): self.vel += 10. Função declarada dentro de uma classe que opera nos dados da instância individual via self.

Construtor (__init__)

def __init__(self, marca): self.marca = marca. Método especial executado automaticamente no momento em que um novo objeto é instanciado.

Destrutor (__del__)

def __del__(self): print('Objeto liberado'). Método especial acionado quando um objeto está prestes a ser destruído da memória.

Encapsulamento

self.__saldo = 0. Prática de ocultar detalhes internos e proteger dados contra alterações diretas e indevidas de fora da classe.

Modificador de Acesso Público

self.nome = 'Ana'. Atributo ou método que pode ser acessado livremente de qualquer parte do código.

Modificador de Acesso Protegido

self._taxa = 0.05. Convenção que indica que o membro deve ser acessado apenas pela classe dona e suas subclasses.

Modificador de Acesso Privado

self.__senha = '123'. Mecanismo que restringe o acesso ao atributo apenas ao escopo interno da própria classe.

Getter

@property\ndef saldo(self): return self.__saldo. Método que expõe a leitura de um atributo privado de forma controlada.

Setter

@saldo.setter\ndef saldo(self, v): self.__saldo = max(0, v). Método que valida e altera o valor de um atributo privado.

Herança Simples

class Gato(Animal): pass. Criação de uma subclasse que herda atributos e métodos de uma única superclasse mãe.

Herança Múltipla

class Smartphone(Camera, Telefone): pass. Capacidade de uma subclasse herdar características de mais de uma superclasse direta.

Função super()

super().__init__(nome). Chamada explícita para invocar métodos da superclasse a partir da subclasse filha.

Sobrescrita de Método (Override)

def falar(self): return 'Miau'. Redefinição na classe filha de um método herdado da classe pai para alterar sua lógica.

Polimorfismo

for a in [Cao(), Pato()]: a.falar(). Capacidade de tratar objetos de classes distintas sob uma mesma interface comum.

Sobrecarga de Método (Overload)

def soma(a, b=0, c=0): return a + b + c. Capacidade de um método responder de maneiras diferentes conforme os argumentos recebidos.

Classe Abstrata

class Base(ABC): pass. Classe que não pode ser instanciada diretamente e serve apenas como modelo base para filhas.

Método Abstrato

@abstractmethod\ndef desenhar(self): pass. Assinatura de método sem corpo que as subclasses concretas são obrigadas a implementar.

Interface

class IAutenticavel(ABC):\n @abstractmethod\n def login(self): pass. Contrato puramente abstrato que define quais métodos uma classe deve expor.

Composição

class Carro:\n def __init__(self): self.motor = Motor(). Relação de posse forte ('tem-um') onde a parte não sobrevive sem o todo.

Agregação

class Time:\n def __init__(self, atletas): self.atletas = atletas. Relação de posse fraca onde os objetos associados existem de forma independente.

Associação

def dirigir(self, carro): pass. Relação genérica entre duas classes que apenas utilizam os serviços uma da outra.

Acoplamento

class A: b = B(). Medida de dependência entre classes; designs robustos priorizam baixo acoplamento entre os módulos.

Coesão

class Relatorio: def gerar(self): pass. Grau de foco de uma classe em realizar uma única responsabilidade de forma bem definida.

Método Estático (@staticmethod)

@staticmethod\ndef soma(x, y): return x + y. Método que não recebe referência de instância nem de classe e funciona como utilitário.

Método de Classe (@classmethod)

@classmethod\ndef criar_padrao(cls): return cls(). Método que recebe a referência da própria classe (cls) em vez da instância.

Duck Typing

def voar(ave): ave.voar(). Princípio onde o tipo do objeto importa menos do que a presença dos métodos necessários.

Princípio da Responsabilidade Única (SRP)

class Auth: def login(self): pass. Princípio SOLID: uma classe deve ter apenas um único motivo para mudar.

Princípio Aberto/Fechado (OCP)

class Pagamento(ABC): pass. Princípio SOLID: classes devem estar abertas para extensão, mas fechadas para modificação.

Princípio de Substituição de Liskov (LSP)

def teste(a: Ave): a.voar(). Princípio SOLID: subclasses devem poder substituir suas superclasses sem quebrar o sistema.

Princípio da Segregação de Interfaces (ISP)

class IImprime(ABC): pass. Princípio SOLID: clientes não devem ser forçados a depender de interfaces que não usam.

Princípio da Inversão de Dependência (DIP)

def __init__(self, repo: IRepo): pass. Princípio SOLID: depender de abstrações em vez de implementações concretas.

Padrão Singleton

if not cls.inst: cls.inst = cls(). Padrão que garante a existência de uma única instância global de uma classe.

Padrão Factory Method

def criar(tipo): return Carro() if tipo=='c' else Moto(). Padrão que encapsula a lógica de criação de objetos variados.

Padrão Strategy

def pagar(self, strat): strat.processar(). Padrão que permite trocar algoritmos em tempo de execução dinamicamente.

Padrão Observer

def notificar(self): [o.update() for o in self.obs]. Mecanismo de publicação e assinatura entre objetos dependentes.

Padrão Decorator

def __init__(self, base): self.base = base. Adiciona comportamentos a um objeto individual dinamicamente sem usar herança.

Método Mágico __str__

def __str__(self): return f'{self.nome}'. Define a representação textual legível de um objeto ao ser impresso.

Método Mágico __repr__

def __repr__(self): return f'Item({self.id})'. Retorna uma representação técnica formal do objeto para depuração.

Sobrecarga de Operador (__add__)

def __add__(self, out): return Ponto(self.x+out.x). Permite usar operadores aritméticos padrão (como +) entre objetos da classe.

Método Mágico __eq__

def __eq__(self, out): return self.id == out.id. Define a lógica de comparação de igualdade (operador ==) entre objetos.

Método Mágico __len__

def __len__(self): return len(self.itens). Permite que o objeto responda à função embutida len() retornando sua extensão.

Imutabilidade de Objeto

@dataclass(frozen=True)\nclass Ponto: x: int. Criação de objetos cujos atributos não podem ser modificados após a criação.

Data Class

@dataclass\nclass User: id: int; nome: str. Recurso que gera automaticamente métodos como construtor e representação textual.

Injeção de Dependência

def __init__(self, servico: Servico): pass. Fornecer dependências externas diretamente à classe em vez de criá-las internamente.

Lei de Demeter

cliente.get_cidade() # evita cliente.end.cidade. Diretriz de baixo acoplamento: um objeto deve falar apenas com vizinhos próximos.

Estado de um Objeto

lâmpada.ligada = True. Conjunto de valores atuais armazenados nos atributos de uma instância em dado momento.