👨🏫 Guia do Professor - Aula 03
Refatoração Segura em Java
Desenvolvimento de Sistemas II
Prof. Ricardo Pires
3º Técnico DS
Duração: 105 minutos (3 aulas de 35 min)
🎯 Visão Geral Pedagógica
📚 Contexto no Curso
Esta é a terceira aula de uma sequência que constrói progressivamente conhecimento em qualidade de código:
- Aula 01: Fundamentos de código limpo e formatação
- Aula 02: DRY (Don’t Repeat Yourself) e reutilização
- Aula 03: Refatoração segura (atual)
- Aula 04: Design Patterns (próxima)
🧠 Objetivos Cognitivos
- Conhecimento: Identificar code smells e técnicas de refatoração
- Compreensão: Entender impacto da refatoração na manutenibilidade
- Aplicação: Usar Extract Method e Decompose Conditional
- Análise: Avaliar qualidade do código antes/depois
- Síntese: Combinar técnicas para resolver problemas complexos
- Avaliação: Julgar quando refatorar e quando não vale a pena
⏰ Cronograma Detalhado
🚀 Aula 1 (35 min): Conceitos e Identificação
⏱️ 0-10 min: Abertura Impactante
🎬 HOOK: "Quem já perdeu horas tentando entender código que vocês mesmos escreveram?"
Dinâmica inicial:
- Pergunta provocativa (2 min): “Mostrar por que código confuso custa caro”
- Exemplo real (5 min): Mostrar método de 50 linhas no projetor
- Definição (3 min): O que é refatoração vs. reescrita
Materiais necessários:
- Método problemático real preparado no projetor
- Cronômetro visível para os alunos
- Quadro com definições principais
⏱️ 10-25 min: Code Smells na Prática
Objetivo: Alunos identificam problemas em código real
Atividade guiada:
- Apresentar código (3 min): Método ProcessadorPedido no slide
- Brainstorming (7 min): Alunos identificam problemas em grupos
- Sistematização (10 min): Professor organiza findings no quadro
- Classificação (5 min): Categorizar por tipos de smell
Script do professor:
“Vejam este método que vocês encontrariam numa empresa real. Em 2 minutos, identifiquem tudo que acham estranho ou difícil. Não tenham medo de apontar problemas!”
Resultado esperado:
- Pelo menos 8 code smells identificados pelos alunos
- Conceitos de método longo, condicionais aninhadas estabelecidos
- Awareness criado sobre custo de manutenção
⏱️ 25-35 min: Introdução à Refatoração Segura
Objetivo: Estabelecer processo Red-Green-Refactor
Conteúdo:
- Definição formal (3 min): Comportamento preservado
- Processo seguro (4 min): Testes → Refatorar → Validar
- Técnicas principais (3 min): Extract Method preview
Ação dos alunos:
- Anotar processo em 3 passos
- Questionar sobre experiências de quebra de código
- Preparar mindset para próxima aula prática
🔧 Aula 2 (35 min): Extract Method Prático
⏱️ 35-40 min: Live Coding Setup
Objetivo: Preparar ambiente para demonstração prática
Professor demonstra:
- Abrir IDE com projeto preparado
- Executar testes para mostrar green state
- Explicar código problemático que será refatorado
Papel dos alunos:
- Acompanhar setup no próprio computador
- Baixar projeto da aula se necessário
- Preparar IDE com mesmo código
⏱️ 40-60 min: Live Coding Extract Method
Objetivo: Demonstrar refatoração passo a passo
Roteiro do live coding:
// PASSO 1: Mostrar testes passando (2 min)
@Test
void testeComportamento() {
// Demonstrar que captura comportamento atual
}
// PASSO 2: Identificar primeira responsabilidade (3 min)
public String processar(Pedido pedido) {
// [HIGHLIGHT] Esta parte valida o pedido
if (pedido == null) return "Erro";
// ... destacar bloco de validação
}
// PASSO 3: Extrair método validação (8 min)
// Demonstrar:
// - Select do código → Extract Method
// - Escolher nome expressivo
// - Executar testes imediatamente
private String validarPedido(Pedido pedido) {
if (pedido == null) return "Erro";
// ... código movido
}
// PASSO 4: Extrair cálculo total (7 min)
// Repetir processo mostrando incrementalidade
// PASSO 5: Resultado final (5 min)
public String processar(Pedido pedido) {
String validacao = validarPedido(pedido);
if (validacao != null) return validacao;
double total = calcularTotal(pedido);
total = aplicarDesconto(pedido.getCliente(), total);
return formatarResultado(total);
}Pontos críticos a enfatizar:
- Testes executados a cada mudança
- Nomes expressivos revelam intenção
- Uma responsabilidade por método
- Comportamento idêntico preservado
⏱️ 60-70 min: Prática Guiada dos Alunos
Objetivo: Alunos aplicam Extract Method com suporte
Dinâmica:
- Distribuir exercício (2 min): Método diferente para refatorar
- Trabalho individual (6 min): Alunos aplicam técnica
- Circulação do professor (2 min): Suporte individual
Exercício prático:
// Método de 30 linhas para os alunos refatorarem
public String gerarRelatorio(Cliente cliente) {
// 3 responsabilidades distintas
// Objetivo: extrair 2-3 métodos
}Indicadores de sucesso:
- 80% dos alunos conseguem extrair pelo menos 1 método
- Testes continuam passando
- Nomes de métodos fazem sentido
🌟 Aula 3 (35 min): Decompose Conditional e Consolidação
⏱️ 70-80 min: Decompose Conditional Demo
Objetivo: Mostrar simplificação de condicionais aninhadas
Demonstração estruturada:
// ANTES (3 min): Mostrar pesadelo de aninhamento
if (user != null) {
if (user.isActive()) {
if (product != null) {
if (product.getStock() > 0) {
// lógica escondida no fundo
}
}
}
}
// DURANTE (4 min): Aplicar guard clauses
public boolean podeComprar(User user, Product product) {
if (user == null) return false;
if (!user.isActive()) return false;
if (product == null) return false;
if (product.getStock() <= 0) return false;
// lógica principal visível
return true;
}
// DEPOIS (3 min): Extrair métodos de validação
public boolean podeComprar(User user, Product product) {
return isUserValid(user) && isProductAvailable(product);
}Pontos pedagógicos:
- Aninhamento dificulta leitura
- Early returns clarificam intenção
- Métodos auxiliares organizam lógica
⏱️ 80-95 min: Exercício Prático Completo
Objetivo: Alunos aplicam ambas técnicas
Setup do exercício:
// Código com AMBOS os problemas:
// - Método longo (Extract Method)
// - Condicionais aninhadas (Decompose Conditional)
public double calcularDesconto(Cliente cliente, Produto produto) {
// 40 linhas de pesadelo
}Processo estruturado:
- Leitura (3 min): Alunos entendem código
- Planejamento (2 min): Identificam estratégia
- Execução (8 min): Refatoração com testes
- Validação (2 min): Conferir métricas
Suporte do professor:
- Circular entre as duplas
- Dar dicas quando travarem
- Validar estratégias escolhidas
- Alertar sobre tempo restante
⏱️ 95-105 min: Fechamento e Meta-aprendizagem
Objetivo: Consolidar aprendizados e conectar com próxima aula
Atividades de fechamento:
- Retrospectiva rápida (3 min): “O que mais os surpreendeu hoje?”
- Métricas comparativas (2 min): Before/after dos exercícios
- Conexão (3 min): Como isso prepara para Design Patterns
- Tarefa de casa (2 min): Aplicar em projeto pessoal
Perguntas-chave para reflexão:
- “Quanto tempo economizariam se tivessem que alterar o código refatorado?”
- “Como isso se relaciona com DRY da aula passada?”
- “Que tipo de refatoração foi mais impactante para vocês?”
🎨 Estratégias Pedagógicas
👥 Perfis de Aprendizagem
🔍 Visual (35% da turma)
- Slides com before/after side-by-side
- Diagramas de fluxo para mostrar complexidade
- Syntax highlighting para destacar mudanças
- Métricas visuais (gráficos de melhoria)
🎧 Auditivo (25% da turma)
- Explicações verbais durante live coding
- Discussões sobre trade-offs
- Apresentações de alunos dos resultados
- Feedback verbal durante exercícios
✋ Cinestésico (40% da turma)
- Hands-on refactoring imediato
- Typing along durante demonstrações
- Experimenting com variações
- Physical code review (circular pela sala)
🧩 Diferenciação Pedagógica
⭐ Alunos Avançados
- Desafios extras: Implement Strategy Pattern
- Mentoring role: Ajudar colegas com dificuldades
- Code review: Analisar soluções de outros alunos
- Research task: Investigar outras técnicas de refatoração
📚 Alunos com Dificuldades
- Código pré-estruturado: Templates com TODO comments
- Pair programming: Duplas estratégicas
- Checklist visual: Passos concretos para cada técnica
- Extra time: Deixar terminar exercícios como tarefa
🎯 Alunos Medianos
- Guided discovery: Perguntas direcionadas
- Progressive complexity: Exercícios que evoluem
- Peer learning: Comparar abordagens com colegas
- Regular check-ins: Validação de progresso
🔧 Adaptações Técnicas
💻 Problemas de Environment
- Backup plan: Código preparado em várias IDEs
- Shared screen: Se computadores falharem
- Paper exercises: Versões impressas dos exercícios
- Mobile backup: Exemplos que funcionam no celular
⏱️ Gestão de Tempo
- Timers visíveis: Cronômetro no projetor
- Flex activities: Exercícios que podem ser cortados
- Extension tasks: Para turmas que terminam cedo
- Priority matrix: Saber o que não pode ser cortado
📊 Avaliação Formativa
🎯 Checkpoints Durante a Aula
Checkpoint 1 (25 min): Identificação
Pergunta-chave: “Quantos code smells vocês encontraram?”
- Meta: 80% identifica pelo menos 3 smells
- Indicadores de sucesso:
- Participação ativa na discussão
- Uso de vocabulário técnico correto
- Conexão com experiências passadas
Ação se meta não atingida:
- Mostrar mais exemplos concretos
- Fazer perguntas mais diretas
- Dar mais tempo para análise
Checkpoint 2 (60 min): Extract Method
Pergunta-chave: “Testes continuam passando após a refatoração?”
- Meta: 75% consegue extrair método mantendo testes verdes
- Indicadores de sucesso:
- Código funcional após refatoração
- Nomes de métodos expressivos
- Compreensão do processo incremental
Ação se meta não atingida:
- Demo adicional step-by-step
- Pair programming forçado
- Simplificar exercício
Checkpoint 3 (95 min): Aplicação Completa
Pergunta-chave: “Conseguem aplicar ambas técnicas no mesmo código?”
- Meta: 70% aplica Extract Method + Decompose Conditional
- Indicadores de sucesso:
- Redução visível de complexidade
- Código mais legível
- Confiança para continuar refatorando
Ação se meta não atingida:
- Estender para tarefa de casa
- Agendar monitoria
- Revisar na próxima aula
📝 Avaliação Informal Contínua
🔍 Observação Direcionada
Durante exercícios, observar:
- Estratégia: Como aluno aborda o problema?
- Persistência: Desiste fácil ou continua tentando?
- Colaboração: Pede ajuda adequadamente?
- Testing: Executa testes regularmente?
❓ Perguntas Diagnósticas
Para usar durante circulação:
- “Por que escolheu extrair esse método primeiro?”
- “Como sabe se a refatoração está funcionando?”
- “Qual parte está mais difícil?”
- “Como uma pessoa nova no projeto entenderia esse código?”
🛠️ Recursos e Materiais
📁 Preparação Pré-aula
💻 Setup Técnico (30 min)
- Projeto Java configurado com JUnit 5
- Código problemático preparado para demonstração
- Testes já escritos para validação
- IDE configurada com plugins de refatoração
- Slides revisados e timing ajustado
📄 Materiais Fisicos
- Handouts com exercícios impressos
- Checklist de técnicas para consulta rápida
- Métricas sheet para before/after comparison
- Backup exercises caso tecnologia falhe
🌐 Recursos Online
- GitHub repo com código da aula
- Links para documentação adicional
- Screencasts de demonstrações para revisão
- Forum ou chat para dúvidas pós-aula
🧰 Toolkit do Professor
⚡ Quick Reference Card
Extract Method: Select → Alt+Shift+M → Name → Enter
Decompose Conditional: Identify guards → Extract methods
Red-Green-Refactor: Test → Change → Test → Commit
📊 Métricas de Acompanhamento
| Métrica | Target | Ferramenta |
|---|---|---|
| Lines/method | < 20 | Manual count |
| Cyclomatic complexity | < 5 | IDE plugin |
| % students successful | > 75% | Observation |
| Engagement level | High | Visual cues |
🏥 Troubleshooting Guide
PROBLEMA: Aluno trava no Extract Method
SOLUÇÃO: Mostrar passo-a-passo no computador dele
PROBLEMA: Testes quebram após refatoração
SOLUÇÃO: Revisar se entrada/saída são idênticas
PROBLEMA: Nomes de métodos ruins
SOLUÇÃO: Brainstorm colaborativo de nomes melhores
PROBLEMA: Turma muito lenta
SOLUÇÃO: Simplificar exercício ou fazer pair programming
📚 Material de Apoio para Alunos
📖 Leitura Pré-aula (Opcional)
- Artigo: “Code Smells” - Martin Fowler (15 min)
- Video: “Refactoring in IntelliJ” - JetBrains (10 min)
- Code example: Análise de código ruim vs. limpo (5 min)
🔗 Links para Aprofundamento
- Refactoring Guru - Técnicas ilustradas
- Fowler’s Refactoring - Referência completa
- Clean Code Cheat Sheet
🎯 Exercícios Extra (Para Casa)
- Projeto pessoal: Aplicar técnicas em código próprio
- Code review: Analisar PRs de projetos open source
- Metrics measurement: Comparar before/after com ferramentas
🔄 Melhoria Contínua
📈 Métricas de Aula
👨🎓 Satisfação dos Alunos
Perguntas anônimas pós-aula (2 min):
- “Clareza das explicações (1-5):”
- “Utilidade dos exercícios (1-5):”
- “Ritmo da aula (muito lento/adequado/muito rápido):”
- “O que mais ajudou no aprendizado?”
- “O que poderia ser melhorado?”
📊 Indicadores de Aprendizagem
- % de alunos que completaram exercícios básicos
- Qualidade dos códigos refatorados produzidos
- Engagement: participação em discussões
- Retention: performance em avaliações posteriores
🔧 Ajustes para Próximas Turmas
📝 Lessons Learned Template
DATA: [data da aula]
TURMA: [identificação]
FUNCIONOU BEM:
- [aspecto 1]
- [aspecto 2]
NÃO FUNCIONOU:
- [problema 1] → [solução proposta]
- [problema 2] → [solução proposta]
TIMING:
- [atividade] → [tempo real] vs [tempo planejado]
AJUSTES PARA PRÓXIMA:
- [ ] [ajuste específico 1]
- [ ] [ajuste específico 2]
🎯 Versioning das Melhorias
- v1.0: Aula inicial conforme este plano
- v1.1: Ajustes baseados na primeira turma
- v1.2: Refinamentos baseados em feedback
- v2.0: Revisão major após 3-5 turmas
👥 Colaboração com Outros Professores
- Sharing: Trocar experiências com colegas
- Observation: Convite para observar a aula
- Co-teaching: Ministrar junto em turmas grandes
- Cross-pollination: Adaptar técnicas de outras disciplinas
📞 Suporte e Contingência
🚨 Planos B, C e D
📡 Falha Técnica Total
Plano B - Papel e caneta:
- Exercícios impressos preparados
- Análise de código no quadro
- Discussão conceitual sem computador
- Role-play de debugging
⏱️ Tempo Insuficiente
Plano C - Priorização:
- CORE (imprescindível): Code smells + Extract Method
- NICE (desejável): Decompose Conditional
- EXTRA (se sobrar): Projeto completo
👥 Turma com Dificuldades
Plano D - Simplificação:
- Exemplos menores e mais diretos
- Mais tempo para cada exercício
- Pair programming obrigatório
- Exercícios como tarefa de casa
📱 Contatos de Emergência
- Suporte técnico: [contato IT da escola]
- Professor substituto: [colega capacitado]
- Material alternativo: [link para backup online]
🎯 Critérios Mínimos de Sucesso
Para considerar a aula bem-sucedida:
- 70%+ dos alunos identifica code smells básicos
- 60%+ consegue aplicar Extract Method
- 80%+ demonstra compreensão conceitual
- Nenhum aluno se sente completamente perdido
Ações se critérios não atingidos:
- Aula de revisão na semana seguinte
- Material complementar obrigatório
- Monitoria individual agendada
- Ajuste no plano das próximas aulas
Preparação é a chave do sucesso! 🚀
Lembre-se: O objetivo não é mostrar tudo que sabemos, mas garantir que alunos aprendam o essencial de forma sólida.