Carga Horária: 20 horas aula.

 

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.

 

 

Conteúdo detalhado:

 

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

* Os apêndices listados são conteúdos adicionais que não fazem parte do curso regular.