O FJ-16 é um laboratório de desenvolvimento em Java focado em boas práticas de programação. Durante o curso, desenvolvemos uma aplicação de análise da bolsa de valores, que busca o histórico de uma base XML e exibe gráficos de indicadores e cotações. Nesse contexto, abordamos testes unitários com JUnit, XML com XStream, gráficos com JFreeChart, interfaces Desktop com Swing e ferramentas de build com Ant e Maven.

Há bastante foco nas boas práticas como refatorações, design patterns, Test Driven Development (TDD) e XP, além de recursos avançados da linguagem Java como reflection.

É indicado para quem acaba de fazer o FJ-11 e deseja aplicar os conceitos aprendidos além de se aprofundar em tópicos mais avançados e práticos.

Esse curso faz parte da Formação Consultor Java junto com o FJ-11 e o FJ-21.

A apostila do FJ-16 está disponível para download no Caelum Alumni para todos os alunos e ex-alunos de qualquer curso da Caelum.

Pré-requisitos: Curso FJ-11 ou equivalente com conhecimento de Orientação a Objetos e Java SE básico.

Posts relacionados no blog

Tornando-se um desenvolvedor pragmático

1. O que é realmente importante?
2. A importância dos exercícios
3. Tirando dúvidas
4. Mais bibliografia
5. Para onde ir depois?

O modelo da bolsa de valores, datas e objetos imutáveis

1. A bolsa de valores
2. Candlesticks: O Japão e o arroz
3. O projeto Tail
4. O projeto Argentum: modelando o sistema
5. Trabalhando com dinheiro
6. Palavra chave final
7. Imutabilidade de objetos
8. Trabalhando com datas: %%Date%% e %%Calendar%%
9. Exercícios: o modelo do Argentum
10. Resumo diário dos negócios
11. Exercícios: fábrica de Candlestick
12. Exercícios opcionais

Testes Automatizados

1. Nosso código está funcionando corretamente?
2. Exercícios: testando nosso modelo sem frameworks
3. Definindo melhor o sistema e descobrindo mais bugs
4. Testes de Unidade
5. JUnit
6. Anotações
7. JUnit4, convenções e anotação
8. Exercícios: migrando os testes do main para JUnit
9. Vale a pena testar classes de modelo?
10. Exercícios: novos testes
11. Para saber mais: Import Estático
12. Mais exercícios opcionais
13. Discussão em aula: testes são importantes?

Trabalhando com XML

1. Os dados da bolsa de valores
2. XML
3. Lendo XML com Java de maneira difícil, o SAX
4. XStream
5. Exercícios: Lendo o XML
6. Separando as candles
7. Test Driven Design - TDD
8. Exercícios: Separando os candles
9. Exercícios opcionais
10. Discussão em aula: Onde usar XML e o abuso do mesmo

Interfaces gráficas com Swing

1. Interfaces gráficas em Java
2. Portabilidade
3. Look And Feel
4. Componentes
5. Começando com Swing - Mensagens
6. Exercícios: Escolhendo o XML com JFileChooser
7. Componentes: JFrame, JPanel e JButton
8. O design pattern Composite: Component e Container
9. Tratando eventos
10. Classes internas e anônimas
11. Exercícios: nossa primeira tela
12. JTable
13. Implementando um TableModel
14. Exercícios: Tabela
15. Exercícios opcionais: melhorando a apresentação
16. Para saber mais
17. Discussão em sala de aula: Listeners como classes top level, internas ou anônimas?

Refatoração: os Indicadores da bolsa

1. Análise Técnica da bolsa de valores
2. Indicadores Técnicos
3. As médias móveis
4. Exercícios: criando indicadores
5. Refatoração
6. Exercícios: Primeiras refatorações
7. Refatorações maiores
8. Discussão em aula: quando refatorar?

Gráficos com JFreeChart

1. JFreeChart
2. Utilizando o JFreeChart
3. Isolando a API do JFreeChart: baixo acoplamento
4. Para saber mais: Design Patterns Factory Method e Builder
5. Exercícios: JFreeChart
6. Exercícios opcionais
7. Nossos indicadores e o design pattern Strategy
8. Exercícios: refatorando para uma interface e usando bem os testes
9. Exercícios opcionais

Mais Swing: layout managers, mais componentes e detalhes

1. Gerenciadores de Layout
2. Layout managers mais famosos
3. Exercícios: usando layout managers
4. Integrando JFreeChart
5. Exercícios: completando a tela da nossa aplicação
6. Indicadores mais Elaborados e o Design Pattern Decorator
7. Exercícios: Indicadores mais espertos e o Design Pattern Decorator
8. Discussão em sala de aula: uso de IDEs para montar a tela

Reflection e Annotations

1. Por que Reflection?
2. Class, Field e Method
3. Usando anotações
4. Usar JTables é difícil
5. Usando bem anotações
6. Criando sua própria anotação
7. Exercícios: ArgentumTableModel
8. Exercícios opcionais: nomes das colunas
9. Para saber mais: Formatter, printf e String.format
10. Para saber mais: parâmetros opcionais
11. Exercícios opcionais: formatações na tabela
12. Discussão em sala de aula: quando usar reflection, anotações e interfaces

Apêndice: O processo de Build: Ant e Maven

1. O processo de build
2. O Ant
3. Exercícios com Ant
4. O Maven
5. O Project Object Model
6. Plugins, goals e phases
7. Exercícios: build com o Maven
8. Uso dentro do Eclipse
9. Discussão em sala de aula: IDE, ant ou Maven?

Apêndice - Mais swing e recursos avançados

1. Input de dados formatados: Datas
2. Exercícios opcionais: filtrando por data
3. Para saber mais: barra de menu
4. Exercício: escolhendo indicadores para o gráfico
5. Dificuldades com Threads e concorrência
6. SwingWorker
7. Exercícios: pesquisando mais na API

Apêndice - Logging com Log4j

1. Usando logs - LOG4J
2. Níveis de logs
3. Appenders e layout
4. Exercícios: Adicionando logging com Log4J
5. O sl4j