Ao término dessas 100 horas de curso, divididos em 3 módulos, você estará capacitado a desenvolver sistemas para web usando Java com os padrões, bibliotecas e frameworks mais reconhecidos pelo mercado, além de desenvolver para desktop usando Swing e conhecer os poderosos recursos do Eclipse 3 e seus plugins.

Um curso completo com os nossos qualificados instrutores, a um preço acessível com facilidade de pagamento. Entre em contato conosco, você também pode conversar diretamente com um dos instrutores.

Pré-requisitos: lógica de programação e conhecimento de alguma linguagem procedural (visual basic, delphi, c, php, etc)

Como Aprender Java

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

O que é Java

1. Java
2. Máquina Virtual
3. Java lento? Hotspot e JIT
4. Versões do Java e a confusão do Java2
5. JVM? JRE? JDK? O que devo baixar?
6. Onde usar e os objetivos do Java
7. Especificação versus implementação
8. Como o FJ-11 está organizado
9. Compilando o primeiro programa
10. Executando seu primeiro programa
11. O que aconteceu?
12. Para saber mais: como é o bytecode?
13. Exercícios: Modificando o Hello World
14. O que pode dar errado?
15. Um pouco mais...
16. Exercícios adicionais

Variáveis primitivas e Controle de fluxo

1. Declarando e usando variáveis
2. Tipos primitivos e valores
3. Exercícios: Variáveis e tipos primitivos
4. Discussão em aula: convenções de código e código legível
5. Casting e promoção
6. O If-Else
7. O While
8. O For
9. Controlando loops
10. Escopo das variáveis
11. Um bloco dentro do outro
12. Para saber mais
13. Exercícios: Fixação de sintaxe
14. Desafios: Fibonacci

Orientação a objetos básica

1. Motivação: problemas do paradigma procedural
2. Criando um tipo
3. Uma classe em Java
4. Criando e usando um objeto
5. Métodos
6. Métodos com retorno
7. Objetos são acessados por referências
8. O método transfere()
9. Continuando com atributos
10. Para saber mais: Uma Fábrica de Carros
11. Um pouco mais...
12. Exercícios: Orientação a Objetos
13. Desafios
14. Fixando o conhecimento

Um pouco de arrays

1. O problema
2. Arrays de referências
3. Percorrendo uma array
4. Percorrendo uma array no Java 5.0
5. Exercícios: Arrays
6. Um pouco mais...
7. Desafios
8. Testando o conhecimento

Modificadores de acesso e atributos de classe

1. Controlando o acesso
2. Encapsulamento
3. Getters e Setters
4. Construtores
5. A necessidade de um construtor
6. Atributos de classe
7. Um pouco mais...
8. Exercícios: Encapsulamento, construtores e static
9. Desafios

Orientação a Objetos – herança, reescrita e polimorfismo

1. Repetindo código?
2. Reescrita de método
3. Invocando o método reescrito
4. Polimorfismo
5. Um outro exemplo
6. Um pouco mais...
7. Exercícios: Herança e Polimorfismo
8. Dicussões em aula: Alternativas ao atributo protected

Eclipse IDE

1. O Eclipse
2. Apresentando o Eclipse
3. Views e Perspective
4. Criando um projeto novo
5. Criando o main
6. Rodando o main
7. Pequenos truques
8. Exercícios: Eclipse
9. Discussão em aula: Refactoring

Orientação a Objetos – Classes Abstratas

1. Repetindo mais código?
2. Classe abstrata
3. Métodos abstratos
4. Aumentando o exemplo
5. Para saber mais...
6. Exercícios: Classes Abstratas
7. Desafios

Orientação a Objetos - Interfaces

1. Aumentando nosso exemplo
2. Interfaces
3. Dificuldade no aprendizado de interfaces
4. Exemplo interessante: conexões com o banco de dados
5. Um pouco mais...
6. Exercícios: Interfaces
7. Exercícios avançados opcionais
8. Discussão em aula: Favorecer composição em relação à herança

Controlando os erros com Exceções

1. Motivação
2. Exercício para começar com os conceitos
3. Exceções de Runtime mais comuns
4. Outro tipo de exceção: Checked Exceptions
5. Um pouco da grande famíla Throwable
6. Mais de um erro
7. Lançando exceções
8. O que colocar dentro do try?
9. Criando seu próprio tipo de exceção
10. Para saber mais: finally
11. Exercícios: Exceções
12. Desafios
13. Discussão em aula: catch e throws em Exception

Pacotes - Organizando suas classes e bibliotecas

1. Organização
2. Diretórios
3. Import
4. Acesso aos atributos, construtores e métodos
5. Usando o Eclipse com pacotes
6. Exercícios: Pacotes

Ferramentas: jar e javadoc

1. Arquivos, bibliotecas e versões
2. Gerando o JAR pelo Eclipse
3. Javadoc
4. Gerando o Javadoc
5. Exercícios: Jar e Javadoc

O pacote java.lang

1. Pacote java.lang
2. Um pouco sobre a classe System
3. java.lang.Object
4. Casting de referências
5. Métodos do java.lang.Object: equals e toString
6. Integer e classes wrappers (box)
7. Autoboxing no Java 5.0
8. java.lang.String
9. java.lang.Math
10. Exercícios: java.lang
11. Desafio
12. Discussão em aula: O que você precisa fazer em Java?

Pacote java.io

1. Conhecendo uma API
2. Orientação a objetos
3. InputStream, InputStreamReader e BufferedReader
4. Lendo Strings do teclado
5. A analogia para a escrita: OutputStream
6. Uma maneira mais fácil: Scanner e PrintStream
7. Um pouco mais...
8. Exercícios: Java I/O
9. Discussão em aula: Design Patterns e o Template Method

Collections framework

1. Arrays são trabalhosos, utilizar estrutura de dados
2. Listas: java.util.List
3. Listas no Java 5.0 com Generics
4. A importância das interfaces nas coleções
5. Ordenação: Collections.sort
6. Exercícios: Ordenação
7. Conjunto: java.util.Set
8. Principais interfaces: java.util.Collection
9. Percorrendo coleções no Java 5
10. Para saber mais: Iterando sobre coleções com java.util.Iterator
11. Mapas - java.util.Map
12. Para saber mais: Properties
13. Para saber mais: Equals e HashCode
14. Para saber mais: Boas práticas
15. Exercícios: Collections
16. Desafios

Programação Concorrente e Threads

1. Threads
2. Escalonador e trocas de contexto
3. Garbage Collector
4. Para saber mais: problemas com concorrência
5. Para saber mais: Vector e Hashtable
6. Um pouco mais...
7. Exercícios
8. Exercícios avançados de programação concorrente e locks

E agora?

1. Exercício prático
2. Certificação
3. Web
4. Revistas
5. Grupos de Usuários
6. Falando em Java - Próximos módulos

Apêndice - Sockets

1. Motivação: uma API que usa os conceitos aprendidos
2. Protocolo
3. Porta
4. Socket
5. Servidor
6. Cliente
7. Imagem geral
8. Exercícios: Sockets
9. Desafio: Múltiplos Clientes
10. Desafio: broadcast das mensagens
11. Solução do sistema de chat

Apêndice - Instalação do Java

1. Escolhendo a VM
2. Instalando no Ubuntu e outros Linux
3. No Mac OS X e Solaris
4. Instalação do JDK em ambiente Windows

Apêndice - Debugging

1. O que é debugar
2. Debugando no Eclipse
3. Perspectiva de debug
4. Degub avançado
5. Profiling
6. Profiling no Eclipse

Enfrentando o Java na Web

1. O grande mercado do Java na Web
2. Bibliografia

Bancos de dados e JDBC

1. Por que usar um banco de dados?
2. Persistindo através de Sockets?
3. A conexão em Java
4. Fábrica de Conexões
5. Design Patterns
6. Exercícios: ConnectionFactory
7. A tabela Contato
8. Javabeans
9. Inserindo dados no banco
10. DAO - Data Access Object
11. Exercícios: Javabeans e ContatoDAO
12. Fazendo pesquisas no banco de dados
13. Exercícios: Listagem
14. Um pouco mais...
15. Exercícios opcionais
16. Outros métodos para o seu DAO
17. Exercícios opcionais - Alterar e remover

O que é Java EE?

1. Como o Java EE pode te ajudar a enfrentar problemas
2. Algumas especificações do Java EE
3. Servidor de Aplicação
4. Servlet Container
5. Preparando o Tomcat
6. Preparando o Tomcat em casa
7. Outra opção: Jetty
8. Integrando o Tomcat no Eclipse
9. O plugin WTP
10. Configurando o Tomcat no WTP

Novo projeto Web usando Eclipse

1. Novo projeto
2. Análise do resultado final
3. Criando nossas páginas e HTML Básico
4. Exercícios: primeira página
5. Para saber mais: configurando o Tomcat sem o plugin
6. Algumas tags HTML

Servlets

1. Páginas dinâmicas
2. Servlets
3. Mapeando uma servlet no web.xml
4. A estrutura de diretórios
5. Exercícios: Primeira Servlet
6. Erros comuns
7. Enviando parâmetros na requisição
8. Pegando os parâmetros da requisição
9. Exercícios: Criando funcionalidade para gravar contatos
10. GET, POST e métodos HTTP
11. Tratando exceções dentro da Servlet
12. Exercício: Tratando exceções e códigos HTTP
13. Init e Destroy
14. Uma única instância de cada servlet
15. Para saber mais: Facilidades das Servlets 3.0
16. Discussão: Criando páginas dentro de uma servlet

JavaServer Pages

1. Colocando o HTML no seu devido lugar
2. Exercícios: Primeiro JSP
3. Listando os contatos com Scriptlet
4. Exercícios: Lista de contatos com scriptlet
5. Exercícios opcionais
6. Misturando código Java com HTML
7. EL: Expression language
8. Exercícios: parâmetros com a Expression Language
9. Para saber mais: Compilando os arquivos JSP

Usando Taglibs

1. Taglibs
2. Instanciando POJOs
3. JSTL
4. Instalação
5. Cabeçalho para a JSTL core
6. For
7. Exercícios: forEach
8. Exercício opcional
9. Evoluindo nossa listagem
10. Fazendo ifs com a JSTL
11. Exercícios: Melhorando a lista de contatos com condicionais
12. Importando páginas
13. Exercícios: Adicionando cabeçalhos e rodapés
14. Trabalhando com links
15. Exercícios: Caminho absoluto
16. Formatando as datas
17. Exercícios: Formatando a data de nascimento dos contatos
18. Para saber mais: Outras tags

Indo além da JSTL

1. Porque eu precisaria de outras tags além da JSTL?
2. Criando minhas próprias tags com Tagfiles
3. Exercícios: criando nossa própria tag para calendário
4. Para saber mais: Outras taglibs no mercado
5. Desafio: Colocando displaytag no projeto

MVC - Model View Controller

1. Servlet ou JSP?
2. Request Dispatcher
3. Exercícios: RequestDispatcher
4. Melhorando o processo
5. Retomando o ::design pattern:: Factory
6. A configuração do web.xml
7. Exercícios: Criando nossas lógicas e servlet de controle
8. Exercícios: Lógica para alterar contatos
9. Exercícios opcionais
10. Model View Controller
11. Lista de tecnologias: camada de controle
12. Lista de tecnologias: camada de visualização
13. Discussão em aula: os padrões Command e Front Controller

Recursos importantes: Filtros e WAR

1. Reduzindo o acoplamento com Filtros
2. Exercícios opcionais: Filtro para medir o tempo de execução
3. Problemas na criação das conexões
4. Tentando outras estratégias
5. Reduzindo o acoplamento com Filtros
6. Exercícios: Filtros
7. Deploy do projeto em outros ambientes
8. Exercícios: Deploy com war

Struts 2

1. Porque precisamos de frameworks MVC?
2. Um pouco de história
3. Configurando o Struts 2
4. Criando as lógicas
5. A lógica Olá Mundo!
6. Exercícios: Configurando o Struts 2 e testando a configuração
7. Adicionando tarefas e passando parâmetros à Action
8. Exercícios: Criando tarefas
9. Incluindo validação no cadastro de tarefas
10. Exercícios: Validando tarefas
11. Listando as tarefas e disponibilizando objetos para a view
12. Exercícios: Listando tarefas
13. Redirecionando a requisição para outra Action
14. Exercícios: Removendo e alterando tarefas
15. Desafio
16. Para saber mais: Outras formas de se trabalhar com o Struts 2
17. Melhorando a usabilidade da nossa aplicação
18. Exercícios: Utilizando AJAX para marcar tarefas como finalizadas

Struts 2: Autenticação e autorização

1. Autenticando usuários: como funciona?
2. Cookies
3. Sessão
4. Configurando o tempo limite
5. Registrando o usuário logado na sessão
6. Exercício: Fazendo o login na aplicação
7. Bloqueando acessos de usuários não logados com Interceptadores
8. Exercícios: Interceptando as requisições
9. Discussão: Qual a diferença entre Filtro e Interceptor?

Uma introdução prática ao Hibernate

1. Mapeamento Objeto Relacional
2. Criando seu projeto para usar o Hibernate
3. Mapeando uma classe Produto para nosso Banco de Dados
4. Configurando o Hibernate com as propriedades do banco
5. Criando nosso banco com o Hibernate
6. Exercícios: preparando nosso projeto para o Hibernate
7. Exercícios: configurando e gerando o schema do banco
8. Trabalhando com os objetos: a Session
9. Exercícios: o HibernateUtil e gravando objetos
10. Criando um DAO para o Hibernate
11. Exercícios: criando o DAO
12. Buscando com uma cláusula where
13. Exercícios
14. Exercícios opcionais: para testar o LAZY
15. Exercício opcional

E agora?

1. Os apêndices dessa apostila
2. Certificação SCWCD
3. Frameworks Web
4. Frameworks de persistência
5. Onde seguir seus estudos

Apêndice - VRaptor3 e produtividade na Web

1. Motivação: evitando APIs complicadas
2. Vantagens de um codigo independente de Request e Response
3. VRaptor 3
4. A classe de modelo
5. Minha primeira lógica de negócios
6. Redirecionando após a inclusão
7. Criando o formulário
8. A lista de produtos
9. Exercícios
10. Aprofundando em Injeção de Dependências e Inversão de Controle
11. Injeção de Dependências com o VRaptor
12. Escopos dos componentes
13. Exercícios: Usando Injeção de Dependências para o DAO
14. Adicionando segurança em nossa aplicação
15. Interceptando requisições
16. Exercícios: Construindo a autenticação e a autorização
17. Melhorando a usabilidade da nossa aplicação
18. Para saber mais: Requsições: Síncrono x Assíncrono
19. Para saber mais: AJAX
20. Adicionando AJAX na nossa aplicação
21. Exercícios opcionais: Adicionando AJAX na nossa aplicação

Apêndice - Servlets 3.0 e Java EE 6

1. Java EE 6 e as novidades
2. Suporte a anotações: @WebServlet
3. Suporte a anotações: @WebFilter
4. Preparando o Glassfish v3.0 em casa
5. Preparando o Glassfish v3.0 no WTP
6. Nossa aplicação usando o Glassfish
7. Exercício: Usando anotação @WebServlet
8. Exercício: Alterando nosso framework MVC
9. Exercício: Alterando nosso FiltroConexao
10. Processamento assíncrono
11. Plugabilidade e Web fragments
12. Registro dinâmico de Servlets

Apêndice - Tópicos da Servlet API

1. Init-params e context-params
2. welcome-file-list
3. Propriedades de páginas JSP
4. Inclusão estática de arquivos
5. Tratamento de erro em JSP
6. Descobrindo todos os parâmetros do request
7. Trabalhando com links com a c:url
8. Context listener
9. O ServletContext e o escopo de aplicação
10. Outros listeners

Apêndice - Struts 1

1. Struts 1 e o mercado
2. Exercícios: Configurando o Struts
3. Uma ação Struts
4. Configurando a ação no struts-config.xml
5. Exercícios: TesteSimplesAction
6. Erros comuns
7. Pesquisando um banco de dados
8. Criando a ação
9. O arquivo WebContent/lista.jsp
10. ListaContatos no struts-config.xml
11. Exercício: ListaContatosAction
12. Resultado condicional com o Struts
13. Exercícios: listagem vazia
14. Resultado do struts-config.xml
15. Novos contatos
16. Formulário
17. Mapeando o formulário no arquivo struts-config.xml
18. Exercício: ContatoForm
19. Erro comum
20. Lógica de Negócios
21. Exercício: AdicionaContatoAction
22. Erros comuns
23. Arquivo de mensagens
24. Exercícios: Mensagens
25. Erros comuns
26. Validando os campos
27. Exercício: validação
28. Erros comuns
29. Exercícios opcionais
30. Limpando o formulário
31. Exercícios: scope
32. Exercícios opcionais
33. O mesmo formulário para duas ações
34. Exercícios opcionais
35. Para saber mais

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 unitários
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: 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. 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. Exercícios: Adicionando logging com Log4J