FJ-16 - Laboratório Java com Swing, XML e Testes

O curso FJ-16 foca no desenvolvimento desktop com Swing usando as boas práticas do desenvolvimento orientado a objetos, integrando a tecnologias como XML com JAXB, testes unitários com JUnit e JFreeChart. Durante o curso, desenvolvemos uma aplicação de análise da bolsa de valores, que busca o histórico de uma base XML dos dados e exibição de gráficos de indicadores e cotações.

Além disso, durante o desenvolvimento, diversos design patterns aparecem no código, juntamente com refatorações e o uso de ferramentas de build, para que o desenvolvedor se habitue com a codificação java do dia a dia.

É o curso indicado para quem acaba de fazer o FJ-11 e deseja colocar em prática os conceitos aprendidos e entrar em tópicos mais avançados e práticos. Entre os tópicos abordados estão Swing, XML, testes unitários, JFreeChart, Ant, Maven, refactoring, annotations e reflection.

Faça já sua reserva

Informações

Carga Horária: 20 horas aula

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

Próximas Turmas

Início Término Período
29/11 13/12 Sabado (9:00 as 17:00)
15/12 19/12 Noturno (19:00 as 23:00)
10/01 24/01 Sabado (9:00 as 17:00)
19/01 21/01 Integral (9:00 as 17:00)
02/02 06/02 Noturno (19:00 as 23:00)
28/03 11/04 Sabado (9:00 as 17:00)
Início Término Período
21/01 23/01 Integral (09:00 as 17:00)
Entre em contato para saber as próximas datas.

Indicação de bibliografia
Bibliografia na Livraria Tempo Real

Conteúdo detalhado do FJ-16

Como Aprender Java

  1. O que é realmente importante?
  2. Sobre os exercícios
  3. Tirando dúvidas
  4. Bibliografia

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: classes básicas para o modelo do Argentum
  9. Exercícios opcionais

Testes Automatizados

  1. Nosso código está funcionando?
  2. Exercícios: testando nosso modelo sem frameworks
  3. Exercícios opcionais: definindo melhor o sistema e descobrindo mais bugs
  4. Testes unitários
  5. Testes funcionais
  6. Testes de integração
  7. JUnit
  8. Anotações
  9. Import Estático
  10. Test Driven Development
  11. Exercícios: migrando os testes do main para JUnit
  12. Exercícios: novos testes
  13. Exercícios opcionais
  14. 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: Separando os candles
  6. Exercícios: Lendo o XML
  7. Exercícios opcionais
  8. Discussão em aula: Onde usar XML e o abuso da tecnologia

Rafatoraçã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. Usando logs - LOG4J
  6. Exercícios: Adicionando logging com Log4J
  7. Refatoração
  8. Exercícios: Primeiras refatorações
  9. Nossos indicadores e o design patterns Decorator e Strategy
  10. Exercícios: refatorando para uma interface e usando bem os testes
  11. Exercícios opcionais
  12. Discussão em aula: quando refatorar?

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 Strings: DateFormat, Formatter, printf e String.format
  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?

Gráficos com JFreeChart

  1. JFreeChart
  2. Preparando um projeto no Eclipse para utilizar o JFreeChart
  3. Utilizando o JFreeChart
  4. Isolando a API do JFreeChart: baixo acoplamento
  5. Para saber mais: Design Patterns Factory Method e Builder
  6. Exercícios: JFreeChart
  7. Exercícios adicionais
  8. Desafio: Imprimir Candles
  9. Desafio: Fluent Interface

Mais Swing: layout managers, threads e detalhes

  1. Gerenciadores de Layout
  2. Layout managers mais famosos
  3. Exercícios: usando layout managers
  4. Dificuldades com Threads e concorrência
  5. SwingWorker
  6. Exercícios: resolvendo os problemas de concorrência com SwingWorker
  7. Integrando JFreeChart
  8. Exercícios: completando a tela da nossa aplicação
  9. Exercícios opcionais: zoom no gráfico e salvar como PNG
  10. Discussão em sala de aula: uso de IDEs para montar a tela

Reflection e Annotations

  1. Porquê Reflection?
  2. Reflection: Class, Field
  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. Exercícios opcionais
  10. 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. Discussão em sala de aula: IDE, ant ou Maven?