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. Palavra chave final
6. Imutabilidade de objetos
7. Trabalhando com datas: %%Date%% e %%Calendar%%
8. Exercícios: o modelo do Argentum
9. Exercícios: fábrica de Candlestick
10. 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. JUnit 4 e suas anotações
8. Test Driven Development - TDD
9. Exercícios: migrando os testes do main para JUnit
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. Exercícios: Separando os candles
7. Exercícios opcionais
8. 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 - Diálogos
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. Formatando Datas: DateFormat
16. Exercícios: formatação
17. Para saber mais
18. 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. Nossos indicadores e o design pattern Strategy
8. Exercícios: refatorando para uma interface e usando bem os testes
9. Exercícios opcionais
10. 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. Indicadores mais Elaborados e o Design Pattern Decorator
8. Exercícios: Indicadores mais espertos e o Design Pattern Decorator
9. Desafio: Imprimir Candles
10. Desafio: Fluent Interface

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. Input de dados formatados: Datas
7. Exercícios opcionais: filtrando por data
8. Para saber mais: barra de menu
9. Exercícios opcionais: escolher os indicador(es) para o gráfico
10. Discussão em sala de aula: uso de IDEs para montar a tela

Reflection e Annotations

1. Por que Reflection?
2. Reflection: Class, Method
3. Usando anotações
4. Usar JTables é difícil
5. Criando sua própria anotação
6. Lendo anotação com Reflection
7. TableModel com Reflection
8. Exercícios: ReflectionTableModel
9. Para saber mais: Formatter, printf e String.format
10. Exercícios opcionais
11. 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 - Swing Avançado

1. Dificuldades com Threads e concorrência
2. SwingWorker
3. Exercícios: resolvendo concorrência com SwingWorker
4. Para saber mais: A parte do JFreeChart

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