// aula 02 · Python · POO
Conceito central — a analogia do Guanabara
É o projeto, a "forma de bolo". Define como todos os objetos daquele tipo vão ser. Não existe no mundo real — é só a especificação.
Ex: a classe Caneta descreve o que toda caneta tem.
É o bolo já feito. Uma caneta de verdade, criada a partir da classe. Cada objeto é independente e pode ter valores diferentes nos atributos.
Ex: c1 = Caneta() cria um objeto
real.
O que compõe um objeto
São as variáveis internas do objeto. Descrevem o que ele tem.
Ex: cor, marca, tipo, ponta,
carga, tampada.
São as funções do objeto. Descrevem o que ele faz ou o que pode ser feito com ele.
Ex:
tampar(), destampar(), escrever(), recarregar().
É a combinação dos valores dos atributos naquele momento.
Ex: caneta azul, destampada,
carga 80%.
Cada objeto gerado a partir de uma classe é uma instância diferente, com seus próprios valores.
Ex:
c1 e c2 são instâncias de Caneta.
Visibilidade dos atributos e métodos
Visível de qualquer lugar do programa.
Acesso restrito à classe que o definiu. Protege os dados internos.
Visível para a classe e para suas subclasses (herança).
Métodos que leem (get) e alteram (set) atributos privados de forma segura.
Os 4 pilares da POO
Focar no que é essencial e ignorar os detalhes desnecessários. Ao criar uma classe Caneta, você não precisa modelar a física do plástico — só o que importa para o programa.
Esconder os dados internos do objeto. Os atributos ficam privados e só são acessados por métodos controlados (getters/setters). Protege a integridade do objeto.
Uma classe pode herdar atributos e métodos de outra. A classe Caneta Especial herda de Caneta tudo que já foi definido, evitando repetição de código.
O mesmo método pode se comportar de formas diferentes dependendo do objeto. Caneta e Lápis podem ter o método escrever(), mas cada um age à sua maneira.
Exemplo prático — classe Caneta (Python)
class Caneta: # Construtor — define os atributos ao criar o objeto def __init__(self, cor, marca): self.__cor = cor # privado self.__marca = marca self.__tampada = True # Getter def get_cor(self): return self.__cor # Métodos def tampar(self): self.__tampada = True def destampar(self): self.__tampada = False def escrever(self): if self.__tampada: print("Destampe a caneta primeiro!") else: print(f"Escrevendo com {self.__cor}") # Criando objetos (instâncias) c1 = Caneta("azul", "BIC") c2 = Caneta("vermelha", "Pilot") c1.destampar() c1.escrever() # → Escrevendo com azul
Outro exemplo — classe BiscoitoCoracao
A classe BiscoitoCoracao modela um biscoito em formato de coração. Ela reúne tudo que um biscoito tem (atributos) e tudo que pode ser feito com ele (métodos).
O símbolo + indica que o atributo ou método é público — qualquer parte do programa pode acessá-lo.
Objetos instanciados a partir de uma mesma classe compartilham as mesmas características (atributos) e métodos.
class BiscoitoCoracao: def __init__(self, tamanho, massa, peso, cobertura): self.tamanho = tamanho self.massa = massa self.peso = peso self.cobertura = cobertura self.cozido = False # começa cru self.temperatura = 20 # temperatura ambiente (°C) def cozinhar(self): self.cozido = True self.temperatura = 180 print(f"Biscoito assado a {self.temperatura}°C!") def congelar(self): self.temperatura = -18 print(f"Biscoito congelado a {self.temperatura}°C.") # Criando uma instância b1 = BiscoitoCoracao("médio", "manteiga", 30, "chocolate") b1.cozinhar() # → Biscoito assado a 180°C! b1.congelar() # → Biscoito congelado a -18°C.
Curiosidade — paradigmas de programação
Paradigma é uma forma de pensar e organizar o código. POO é apenas um dos paradigmas existentes — há várias outras maneiras de programar, e muitas linguagens modernas suportam mais de um estilo ao mesmo tempo.
Foram projetadas com POO como base (ou suportam plenamente):
Java é famosa por ser "puramente" OO — quase tudo é uma classe.
Foram criadas com outros paradigmas como foco principal:
C é procedural puro — base de sistemas operacionais e de linguagens mais modernas.
Outros paradigmas além de OO
O código é uma sequência de instruções e procedimentos (funções). É o estilo mais clássico — pensa em o que fazer passo a passo. Exemplos: C, Pascal, Fortran.
Tudo é baseado em funções matemáticas puras, sem efeitos colaterais. Dados são imutáveis. Muito usada em processamento de dados e sistemas robustos. Exemplos: Haskell, Elixir, Clojure.
O programa é definido por fatos e regras — e o computador deduz as respostas. Muito usado em inteligência artificial e linguística computacional. Exemplo clássico: Prolog.
Muitas linguagens modernas não escolhem apenas um estilo. Python, JavaScript e Scala misturam OO com funcional — você usa o que fizer mais sentido para o problema.
Não existe paradigma "melhor" — cada um tem seu contexto ideal. Python é tão querido justamente por ser multiparadigma: você usa POO quando faz sentido, funções puras quando é mais claro, e procedural quando é mais simples. A escolha depende do problema!