roteiro da aula

O que vamos aprender hoje

ponte com as aulas anteriores

De onde paramos — sabemos codar POO

• 🧱 Já escrevemos classes com atributos e métodos (aulas 02, 03), encapsulamento (04), herança (07) e composição (05).
• 🔗 E na aula 18 guardamos VÁRIOS objetos em coleções (self.alunos = []). Na UML isso vira a multiplicidade *: "1 Turma tem * Alunos" — as listas da 18 são as associações 1→* do diagrama.
• 🗺️ Hoje a gente não aprende um recurso NOVO de Python — aprende a DESENHAR o que já sabe escrever.
• 🧭 UML é o mapa antes da viagem: você vê a estrutura inteira do sistema antes de digitar a primeira linha.

o problema

O problema: codar sem planejar

• 🔨 Sair codando direto, sem pensar na estrutura, costuma dar em retrabalho: classes que não encaixam, relações erradas, refação.
• 📐 Um arquiteto não levanta a parede antes da planta. UML é a planta do seu sistema de classes.
• 👥 E é um idioma comum: o diagrama comunica a estrutura pra qualquer pessoa do time, mesmo antes de existir código.

definição

O que é UML

• 📖 UML = Unified Modeling Language (Linguagem de Modelagem Unificada). Uma linguagem VISUAL padrão pra descrever sistemas orientados a objetos.
• 🌐 É independente de linguagem de programação: o mesmo diagrama serve pra Python, Java ou C#. Ela modela a IDEIA, não o código.
• 🎯 A UML tem vários tipos de diagrama. Hoje focamos só no mais usado no dia a dia: o diagrama de classes.

panorama

Os diagramas da UML (e qual usamos)

a caixa de classe

A caixa de classe — 3 compartimentos

Toda classe na UML é uma caixa dividida em três faixas: o nome no topo, os atributos no meio, os métodos embaixo.

a caixa de classe

A mesma classe em Python

A caixa do slide anterior vira código quase 1 pra 1: o nome vira class, os atributos viram self.algo, os métodos viram def.

class Aluno:
    def __init__(self, nome, matricula, cpf):
        self.nome = nome              # + público
        self.matricula = matricula    # + público
        self.__cpf = cpf              # - privado (dois underscores)

    def matricular(self, turma):
        print(f"{self.nome} entrou na turma {turma}")

    def media(self):
        return 0.0

aluno = Aluno("Ana", "2024001", "111.222.333-44")
print(aluno.nome)               # Ana
print(aluno.matricula)          # 2024001
aluno.matricular("INFO-1")      # Ana entrou na turma INFO-1
print(aluno.media())            # 0.0

a caixa de classe

Visibilidade: + - #

a caixa de classe

Visibilidade na prática

Os mesmos três níveis, lado a lado: o símbolo na caixa UML e o que ele vira em Python (a convenção de underscores da aula 04).

+----------------------+
|     ContaBancaria    |
+----------------------+
|  + titular: str      |
|  # saldo: float      |
|  - senha: str        |
+----------------------+

class ContaBancaria:
    def __init__(self, titular, senha):
        self.titular = titular    # + público
        self._saldo = 0.0         # # protegido
        self.__senha = senha      # - privado

a caixa de classe

Tipos e parâmetros na caixa

A UML também anota o TIPO de cada atributo (depois do :) e os parâmetros e o retorno de cada método.

as relações

As relações entre classes

• △ Herança (generalização): triângulo vazio apontando pro pai. "Pato É UM Animal" — aula 07.
• ◆ Composição: losango CHEIO. "Casa CONTÉM Cômodos, e os cômodos somem junto com a casa" — aula 05.
• ◇ Agregação: losango VAZIO. "Time USA Jogadores, mas o jogador existe sozinho" — aula 05.
• — Associação simples: uma linha. "Médico CONHECE Paciente: um sabe do outro", sem a ideia de todo-parte.

as relações

Herança (generalização) → △

O triângulo vazio aponta pro PAI. A frase é sempre "É UM": Aluno é um Pessoa, Professor é um Pessoa.

as relações

Herança UML → Python

O triângulo △ da UML vira (Pai) no Python. O super().__init__() reaproveita o construtor do pai.

class Pessoa:
    def __init__(self, nome, cpf):
        self.nome = nome
        self.__cpf = cpf
    def __str__(self):
        return f"Pessoa: {self.nome}"

# herança: o triângulo △ da UML vira (Pessoa) no Python
class Aluno(Pessoa):
    def __init__(self, nome, cpf, matricula):
        super().__init__(nome, cpf)   # reaproveita o __init__ do pai
        self.matricula = matricula
    def __str__(self):
        return f"Aluno: {self.nome} (mat. {self.matricula})"

ana = Aluno("Ana", "111.222.333-44", "2024001")
print(ana)                  # Aluno: Ana (mat. 2024001)
print(isinstance(ana, Pessoa))   # True  (Aluno É UM Pessoa)

as relações

Composição → ◆ (losango cheio)

Losango CHEIO no lado do TODO. A frase é "CONTÉM": o todo cria a parte, e a parte morre junto com ele.

as relações

Agregação → ◇ (losango vazio)

Losango VAZIO no lado do todo. A frase é "USA": o todo recebe a parte pronta, e ela vive independente.

as relações · a confusão clássica

Composição vs Agregação

As duas são "TEM UM". O que muda é o ciclo de vida da parte: a composição cria a parte, a agregação só usa uma que já existe.

class Pedido:
    def __init__(self, numero):
        self.numero = numero
        # CRIA a parte dentro de si
        self.itens = []
# sem o Pedido, os itens não existem.
# losango CHEIO.

class Turma:
    def __init__(self, professor):
        # RECEBE a parte já pronta
        self.professor = professor
# o professor existe sem a turma.
# losango VAZIO.

as relações

Associação e multiplicidade

Uma linha simples liga classes que se conhecem. Os números nas pontas (a multiplicidade) dizem QUANTOS de cada lado.

as relações

Classe abstrata na UML

Uma classe abstrata (ABC, aula 10) aparece com o estereótipo «abstract» e, na tradição, o nome em itálico.

lendo o todo

Diagrama completo de um mini sistema

Juntando tudo: herança (△), associação com multiplicidade (1/*) e agregação (◇) num diagrama só.

lendo o todo

Lendo o diagrama em voz alta

• 🔼 "Aluno É UM Pessoa" — o triângulo aponta pra Pessoa, então Aluno herda nome e cpf dela.
• 🔢 "Uma Turma TEM vários Alunos" — a multiplicidade 1 para * conta os dois lados da associação.
• ◇ "A Turma USA um Professor" — losango vazio: o professor existe independente da turma (agregação).
• 🗣️ A regra: toda relação vira uma frase. Se você consegue ler o diagrama em voz alta, você entendeu o sistema.

na prática

Ferramentas: draw.io e PlantUML

• 🖱️ draw.io (diagrams.net): você ARRASTA as caixas e setas com o mouse. Visual, gratuito, ótimo pra começar.
• ⌨️ PlantUML: você ESCREVE o diagrama como texto e ele gera a imagem. Bom pra versionar junto com o código (é texto puro).
• ✏️ No papel ou no quadro também vale! O importante é pensar a estrutura antes — a ferramenta é só o meio.

na prática

PlantUML — o diagrama em texto

No PlantUML, o diagrama inteiro é texto entre @startuml e @enduml. Cada relação tem um símbolo de seta.

@startuml
skinparam classAttributeIconSize 0

class Pessoa {
  + nome: str
  - cpf: str
}
class Aluno {
  + matricula: str
}
class Professor {
  + salario: float
}
class Turma {
  + codigo: str
}

Aluno --|> Pessoa
Professor --|> Pessoa
Turma o-- Professor
Turma "1" -- "*" Aluno
@enduml

ao vivo · vamos construir juntos

Exercício ao Vivo: do diagrama ao código

Partindo do diagrama do próximo slide, a gente implementa juntos. Sistema: um Carro que É UM Veiculo (herança) e que CONTÉM um Motor (composição). Acompanhem a tradução de cada seta pra código.

ao vivo · vamos construir juntos

O diagrama do nosso sistema

Em vez de desenhar no quadro, partimos deste diagrama. Leia as duas setas — e nos próximos slides a gente traduz cada uma pra código.

resolução · passos 1 e 2

As peças: Motor e Veiculo

Começamos pelas classes que não dependem do carro: o Motor (a parte que ele vai conter) e o Veiculo (a base da herança).

# Motor é PARTE do Carro (composição ◆): o Carro cria o próprio motor
class Motor:
    def __init__(self, potencia):
        self.potencia = potencia
    def __str__(self):
        return f"Motor {self.potencia}cv"

class Veiculo:
    def __init__(self, marca):
        self.marca = marca

resolução · passos 3 e 4

Carro(Veiculo): herança + composição

Agora o Carro: ele herda de Veiculo com super() e contém um Motor criado no próprio __init__.

# Carro É UM Veiculo (herança △)
class Carro(Veiculo):
    def __init__(self, marca, potencia):
        super().__init__(marca)           # herança: reaproveita o pai
        self.motor = Motor(potencia)      # composição: cria o motor dentro de si
    def __str__(self):
        return f"{self.marca} — {self.motor}"

carro = Carro("Fiat", 75)
print(carro)
print(isinstance(carro, Veiculo))

resolução · o código completo

Tudo junto: a resolução completa

As peças que montamos passo a passo, agora num arquivo só — é exatamente isto que você roda. Repare como herança e composição convivem no mesmo Carro.

# Motor é PARTE do Carro (composição ◆): o Carro cria o próprio motor
class Motor:
    def __init__(self, potencia):
        self.potencia = potencia
    def __str__(self):
        return f"Motor {self.potencia}cv"

class Veiculo:
    def __init__(self, marca):
        self.marca = marca

# Carro É UM Veiculo (herança △)
class Carro(Veiculo):
    def __init__(self, marca, potencia):
        super().__init__(marca)           # herança: reaproveita o pai
        self.motor = Motor(potencia)      # composição: cria o motor dentro de si
    def __str__(self):
        return f"{self.marca} — {self.motor}"

carro = Carro("Fiat", 75)
print(carro)
print(isinstance(carro, Veiculo))

resolução · saída esperada

A saída no terminal

Rodando o carro.py, é isto que aparece no terminal:

Fiat — Motor 75cv
True

recapitulando

Glossário rápido de hoje

O que dominamos hoje

• ✓
  Sei o que é UML e pra que serve o diagrama de classes: planejar a estrutura antes de codar.
• ✓
  Desenho a caixa de uma classe com os três compartimentos (nome, atributos, métodos).
• ✓
  Uso a visibilidade + (público), - (privado) e # (protegido), casando com os underscores do Python.
• ✓
  Reconheço e desenho herança (△), composição (◆), agregação (◇) e associação com multiplicidade.
• ✓
  Sei a diferença entre composição ◆ (a parte some junto) e agregação ◇ (a parte vive sozinha).
• ✓
  Traduzo um diagrama UML em classes Python: △ vira (Pai)+super(), ◆ vira a parte criada no __init__.

exercícios

Mãos à obra: os exercícios

Quatro exercícios em três níveis, do desenho ao código e de volta ao desenho. Comece em sala; termine o que faltar em casa. Mire pelo menos um de cada nível.