02.01. Criando o primeiro programa Java
02.03. Desafio - correção de erros
02.04. Escrevendo comentários no código
02.07. Trabalhando com variáveis
02.08. Operadores aritméticos
02.09. Desafio - variáveis e operadores aritméticos
02.10. Abreviando operadores aritméticos
02.11. Operadores de incremento e decremento
02.12. Tipos primitivos - boolean, char, byte e short
02.13. Tipos primitivos - int e long
02.14. Tipos primitivos - float e double
02.15. Conversão de tipos primitivos
02.16. Desafio - tipos primitivos e conversão
02.17. Promoção aritmética
02.18. Desafio - promoção aritmética
02.19. Trabalhando com String
02.20. Usando sequências de escape
02.21. Formatando a saída com printf
02.22. Recebendo entrada de dados
02.23. Desafio - String, entrada de dados, printf, etc
03.01. Operadores de igualdade e de negação (unário)
03.02. Operadores de comparação
03.03. Operadores lógicos
03.04. Desafio - operadores de igualdade e lógicos
03.05. Curto-circuito de operadores lógicos
03.06. Precedência de operadores lógicos
03.07. Estrutura condicional if
03.08. Estruturas condicionais else e else if
03.09. Desafio - calculadora complexa de IMC
03.10. Escopos e inicialização de variáveis
03.11. Estrutura condicional switch
03.13. Switch Expressions
03.15. Desafio - estrutura switch e operador ternário
03.16. Estrutura de repetição for
03.17. Estrutura de repetição while
03.18. Estrutura de repetição do-while
03.19. Cláusulas break e continue
03.20. Desafio - estruturas de repetição
04.07. Usando o Debugger para depurar o seu código
05.03. Criando uma classe com atributos
05.04. Instanciando objetos
05.05. Acessando atributos de objetos
05.06. Conhecendo o diagrama de classes da UML
05.07. Desafio - instanciando objetos e acessando os atributos
05.08. Composição de objetos
05.09. Atribuindo o objeto na composição
05.10. Diagrama de classes - associação, agregação e composição
05.11. Valores padrão e inicialização de variáveis de instância
05.12. Inicialização de objetos em variáveis de instância
05.13. Caindo a ficha - variáveis referenciam objetos
05.14. Criando e invocando um método
05.15. Implementando a lógica do método
05.17. Métodos com retorno
05.18. Implementando métodos menores e evitando duplicação de código
05.19. Saindo do método com a cláusula return
05.20. Métodos que retornam objetos
05.21. Refatorando para tornar uma classe mais rica
05.22. Discutindo nome e responsabilidade da classe
05.23. Métodos com argumentos
05.24. Passando objetos como argumentos de métodos
05.25. Desafio - composição de objetos e métodos
05.26. Diagrama de classes - métodos e dependências
05.27. Métodos que alteram variável de instância
05.28. Métodos que alteram o valor de parâmetro do tipo primitivo
05.29. Métodos que alteram o estado de objeto recebido como parâmetro
05.30. Usando a palavra-chave this
05.31. Atributos de classe com o modificador static
05.32. Método de instância alterando variável estática
05.33. Métodos de classe (estáticos)
05.34. Método estático acessando membro de instância
05.35. Desafio - membros estáticos
05.36. Declarando constantes com static e final
05.37. Modificador final em variáveis locais
05.38. Sobrecarga de métodos
05.39. Inferência de tipo de variável local
05.41. Desafio - sobrecarga de métodos
06.03. Código Limpo - tamanho e organização de classes
06.04. Código Limpo - comentários no código
06.05. Código Limpo - métodos pequenos e que fazem só uma coisa
06.06. Código Limpo - pensando melhor nos argumentos de métodos
06.07. Boas práticas - valide os argumentos
07.01. Usando classes wrapper
07.02. Métodos de conversão
07.03. Autoboxing e unboxing
07.04. Comparando wrappers
07.05. Desafio - wrappers e boxing/wrappers-boxing/src
07.06. Boas práticas - prefira tipos primitivos a wrappers
08.01. Declarando e inicializando arrays
08.02. Acessando e atribuindo elementos de arrays
08.03. Iterando em arrays
08.04. Transformando arrays em representações em string
08.05. Ordenando arrays em ordem natural e reversa
08.06. Criando arrays de objetos
08.07. Iterando em arrays de objetos
08.08. Copiando e expandindo arrays
08.09. Removendo elementos de arrays
08.11. Um pouco da ArrayList da Collections API
08.12. Desafio - ArrayList
08.13. Diagrama de classes - multiplicidade para arrays
08.14. Boas práticas - retorne arrays ou coleções vazias no lugar de null
08.15. Criando arrays multidimensionais
08.16. Iterando em arrays multidimensionais
08.17. Lendo os parâmetros da linha de comando
08.18. Criando métodos com argumentos variáveis com Varargs
08.19. Boas práticas - use varargs com cuidado
09.03. Informações da Memória Heap com a Runtime API
09.06. Inalcançabilidade de objetos
09.07. Quando esgota a Memória Heap - OutOfMemoryError
09.08. Boas práticas - remova referências de objetos não usados
10.01. Criando e chamando construtores
10.02. Construtores com parâmetros
10.03. Sobrecarga de construtores
10.04. Boas práticas - valide os argumentos de construtores também
10.05. Encadeamento de chamadas de construtores
10.06. Diagrama de classes - construtores
10.07. Desafio - construtores
10.08. Modificador final em variáveis de instância
10.09. Organizando as classes em pacotes
10.10. Importando classes de pacotes
10.11. Modificador de acesso public e default
10.13. Diagrama de classes - visibilidade public, package e private
10.14. Desafio - pacotes e modificadores de acesso
10.15. Importando membros estáticos (static import)
10.16. Múltiplas classes não-públicas em um único arquivo
11.01. O problema da falta de encapsulamento
11.02. Implementando encapsulamento
11.03. JavaBeans e métodos getters e setters
11.05. Desafio - encapsulamento e JavaBeans
11.06. Boas práticas - use métodos de acesso em classes públicas (incluindo Tell Don't Ask)
11.07. Código limpo - Lei de Demeter (incluindo Train Wreck)
11.08. Boas práticas - não permita instanciação com construtor privado
11.09. Boas práticas - crie cópias defensivas
11.10. Boas práticas - minimize a mutabilidade (incluindo Value Object)
11.12. Diagrama de classes - Records
12.01. Conhecendo o projeto deste módulo
12.02. Criando classes etiquetadas (tagged classes)
12.03. Duplicando classes e isolando os comportamentos
12.04. Conhecendo herança e o relacionamento no diagrama de classes
12.05. Implementando herança
12.06. Sobrescrita de métodos
12.07. Modificador de acesso protected
12.08. Anotação @Override
12.09. Chamando método da superclasse com super
12.11. Invocando construtores da superclasse
12.12. Criando construtores com parâmetros na superclasse e subclasses
12.13. Boas práticas - sempre sobrescreva o método Object.toString
12.14. Modificador final em classes e métodos
12.15. Desafio - implementando herança
12.16. Sobrescrevendo o método Object.equals
12.17. Boas práticas - obedeça o contrato ao sobrescrever o método equals
13.01. Upcasting de referências
13.02. O problema que polimorfismo resolve
13.03. Entendendo o polimorfismo
13.04. Downcasting de referências
13.05. Operador instanceof
13.06. Pattern Matching para o operador instanceof
13.07. Evitando o uso de instanceof
13.08. Criando um projeto de faturamento
13.11. Desafio - polimorfismo e classes abstratas
14.02. Criando a primeira interface
14.03. Implementando a primeira interface
14.04. Nova interface e injeção de dependências
14.05. Conhecendo o projeto da financeira
14.06. Quando herança de classes se torna um problema
14.07. Código mais flexível - refatorando para usar interfaces
14.08. Métodos default em interfaces
14.09. Classes abstratas com interfaces
14.10. Métodos privados em interfaces
14.11. Métodos estáticos em interfaces
14.12. Variáveis são estáticas e finais em interfaces
14.13. Implementando múltiplas interfaces
14.14. Herança de interfaces
14.15. Desafio - interfaces
15.01. Rigidez do código com herança
15.02. Boas práticas - prefira composição em vez de herança de classes
15.03. Código frágil - alto acoplamento com herança
15.04. Boas práticas - reduzindo acoplamento com composição
15.05. Decorator Pattern - consolidando os conhecimentos
15.06. Boas práticas - projete interfaces com cuidado
15.07. Boas práticas - use interfaces apenas para definir tipos
15.08. Boas práticas - referencie objetos por suas interfaces
16.01. Introdução às exceções
16.03. Stack Trace - interpretando e analisando exceções
16.04. Capturando exceções com try-catch
16.05. Relançando exceções e printStackTrace
16.06. Capturando exceções com múltiplos blocos catch
16.07. Hierarquia das exceções, checked e unchecked exceptions
16.08. Capturando checked exceptions
16.09. Criando exceções customizadas
16.10. Variáveis de instância em exceções customizadas
16.11. Lançando e propagando checked exceptions
16.12. Capturando exceções menos específicas (upcasting)
16.13. Capturando e lançando nova exceção
16.14. Boa prática - embrulhe a causa raiz
16.15. Capturando exceções com multi-catch
16.16. Usando a cláusula finally
16.17. IntelliJ IDEA - lançando exceções na ferramenta de debug
16.18. IntelliJ IDEA - adicionando Java Exception Breakpoints
16.19. Boas práticas - lance exceções ao invés de retornar null
16.20. Boas práticas - não engula exceções
16.21. Desafio - exceções
17.01. Introdução aos Generics
17.02. Implementando métodos genéricos
17.03. Delimitando tipos genéricos
17.04. Criando classes genéricas
17.05. Criando interfaces genéricas
17.06. Usando curingas para tipos desconhecidos
17.07. Desafio - Generics
18.04. Usando listas do tipo ArrayList
18.05. Iterando em lista com for tradicional
18.06. Usando listas com Generics
18.07. Localizando objetos em listas
18.08. Manipulando objetos da lista
18.09. Percorrendo a lista com Iterator
18.10. Percorrendo a lista com ListIterator
18.11. Percorrendo Iterables com enhanced for
18.13. Usando listas do tipo LinkedList
18.14. Vector - a lista thread-safe
18.15. Boas práticas - reduza o acoplamento usando o tipo da interface
18.16. Convertendo de lista para array
18.17. Ordenando listas pela ordem natural
18.18. Boas práticas - considere implementar a interface Comparable
18.19. Comparators - ordenando listas com outros critérios
18.22. Usando conjuntos do tipo HashSet
18.24. Implementando o método hashCode
18.25. Testando a implementação de hashCode com HashSet
18.26. Usando conjuntos do tipo TreeSet
18.27. Usando conjuntos do tipo LinkedHashSet
18.28. Desafio - conjuntos
18.30. Usando mapas dos tipos HashMap e Hashtable
18.31. LinkedHashTable e TreeMap - outras implementações de mapas
18.33. Boas práticas - encapsulamento com coleções não-modificáveis
18.34. Coleções imutáveis
18.35. Usando a API de List para manipular arrays
19.01. Usando enumerações à moda antiga
19.02. Criando tipos Enum
19.03. Diagrama de classes - enumeração
19.04. Usando os métodos do tipo Enum
19.05. Declarando e inicializando propriedades e construtores
19.06. Implementando métodos
19.07. Implementando métodos abstratos
19.08. Boas práticas - substitua parâmetros booleanos por enums
19.09. Desafio - enumerações
20.01. Comparação de strings
20.03. Validando o conteúdo de strings
20.06. Transformando strings
20.07. Implementando algoritmos usando os métodos da classe String
20.08. Desafio - validação de e-mail
20.09. Testando correspondências de strings com expressões regulares
20.10. Web Scraping - Buscando correspondências com Pattern e Matcher
20.11. Manipulando strings com expressões regulares
20.12. Boas práticas - use StringBuilder para mais performance
20.13. Código mais limpo com Text blocks
20.14. Desafio - Text blocks e expressões regulares
21.01. Comparando números da forma correta
21.03. Operações matemáticas com java.lang.Math
21.04. Boas práticas - evite float e double se precisão é importante
21.05. Precisão nos cálculos com BigDecimal
21.06. Divisão de BigDecimal e formas de arredondamento
21.07. Formatação decimal com DecimalFormat
21.08. Localizando a formatação de números com Locale
21.09. Formatação numérica compacta
21.10. Transformando String em números com DecimalFormat
21.11. Desafio - formatação numérica
22.02. Instanciando datas com o tipo Date
22.03. Calculando e comparando datas com Date
22.04. Formatando Date para String
22.05. Convertendo de String para Date
22.06. Conhecendo o tipo Calendar
22.07. Obtendo unidades de tempo e atribuindo uma Date em Calendar
22.08. Operações de datas com o tipo Calendar
22.09. Comparando datas com o tipo Calendar
22.10. Desafio - calculando datas com Calendar
23.01. Introdução à Date and Time API e ao padrão ISO-8601
23.02. Instant - representando um momento na linha do tempo
23.03. LocalDate - representando apenas a data
23.04. LocalTime - representando apenas o horário
23.05. LocalDateTime - representando data e hora
23.06. Outras formas de obter instâncias de LocalDate, LocalTime e LocalDateTime
23.07. Formatando data-hora da nova API
23.08. Convertendo de String para objetos temporais
23.09. Desafio - LocalDate, LocalTime e LocalDateTime
23.10. Obtendo campos de objetos temporais e a enum ChronoField
23.11. Alterando campos de objetos temporais com métodos with
23.12. Adicionando e subtraindo objetos temporais com métodos de conveniência
23.14. Desafio - calculadora de parcelas
23.15. Representando períodos com a classe Period
23.16. Calculando períodos de objetos temporais
23.17. Representando durações com a classe Duration
23.18. Calculando durações de objetos temporais
23.19. Desafio - calculando período
23.20. DayOfWeek - representando o dia da semana
23.21. Year - representando o ano
23.23. MonthDay - representando o dia do mês
23.24. YearMonth - representando o mês do ano
23.25. Alterando campos de objetos temporais com TemporalAdjusters
23.26. Comparando objetos temporais
23.27. Desafio - TemporalAdjuster
23.28. Identificando fusos com ZoneId e ZoneOffset
23.29. Instanciando objetos temporais em um fuso horário específico
23.30. ZonedDateTime - data-hora com fuso horário
23.31. Calculando e convertendo de-para ZonedDateTime
23.32. OffsetDateTime e OffsetTime - data e hora com deslocamento do UTC
23.33. Desafio - trabalhando com fuso horário
24.02. Classes aninhadas estáticas
24.03. Modificadores de acesso de classes aninhadas
24.04. Enum como membro estático de uma classe
24.05. Classes aninhadas não-estáticas
24.06. Shadowing em classes aninhadas
24.09. Desafio - classes aninhadas
25.01. Introdução ao módulo
25.02. Implementando Expressões Lambda
25.03. Entendendo as interfaces funcionais
25.04. Usando a interface @FunctionalInterface
25.05. Boas práticas - prefira lambdas a classes anônimas
25.06. Boas práticas - torne as lambdas mais concisas
25.07. Implementando Comparator com lambda
25.08. Boas práticas - prefira interfaces funcionais padrão
25.09. As 4 principais interfaces funcionais
25.10. Interface funcional Predicate - removendo elementos de coleções
25.11. Interface funcional Consumer - iterando em coleções com forEach
25.12. Interface funcional Function - ordenando lista com Comparator.comparing
25.13. Usando Method References
25.14. Referenciando métodos de uma instância particular
25.15. Referenciando métodos estáticos
25.16. Referenciando construtores
25.17. Desafio - expressões lambda e method reference
26.01. O jeito tradicional de evitar NPE
26.02. Evoluindo seu código com Optional
26.03. Testando valor do Optional com isPresent
26.04. Obtendo valor e lançando exceção com orElseThrow
26.05. Obtendo valor alternativo com orElse e orElseGet
26.06. Obtendo e testando valor com ifPresent e ifPresentOrElse
26.07. Testando e filtrando valor com Predicate
26.08. Aplicando transformações com map
26.09. Aplicando transformações com flatMap
26.10. Tipos especiais de Optional para tipos primitivos
26.12. Desafio - Optional
27.01. Introdução à Streams API e operações básicas
27.02. Operação intermediária - Stream.filter
27.03. Operação terminal - Stream.forEach
27.04. Criando o pipeline com encadeamento de operações
27.05. Executando ações intermediárias com o método Stream.peek
27.06. Operações terminais de curto-circuito - findFirst e findAny
27.07. Testando predicados com Stream.anyMatch, Stream.allMatch e Stream.noneMatch
27.08. Ordenando elementos de Streams
27.09. Entendendo o que é uma operação intermediária com estado (stateful)
27.10. Aplicando transformações com Stream.map
27.11. Obtendo um Stream de elementos distintos
27.12. Achatando um Stream com Stream.flatMap
27.13. Usando as especializações de Stream para tipos primitivos
27.14. Entendendo as operações de redução com Stream.reduce
27.15. Reduzindo em BigDecimal e usando a função de combinação
27.16. Operações de redução que retornam Optional
27.17. Operações de redução especiais - sum, average e count
27.18. Operações de redução especiais - min e max
27.19. Coletando elementos do Stream em lista com Stream.collect
27.20. Usando coletores padrão da classe Collectors
27.21. Usando coletores de listas não-modificáveis
27.22. Coletando elementos do Stream em mapas
27.23. Gerando mapas agrupados com Collectors.groupingBy
27.24. Gerando mapas agrupados com valores agregados
27.25. Gerando mapas particionados com Collectors.partitioningBy
27.26. Outras formas de obter instâncias de Stream
27.27. Métodos Objects.isNull e Objects.nonNull
27.28. Boas práticas - prefira funções em streams sem efeito colateral
28.02. Instanciando e criando arquivos e pastas com a classe File
28.03. Obtendo o caminho absoluto e canônico de File
28.04. Excluindo, renomeando e movendo arquivos e pastas
28.05. Obtendo informações de arquivos e diretórios
28.06. Listando arquivos e diretórios
28.08. Lendo arquivos com FileInputStream
28.09. Boa prática - tratando IOException com try-with-resources
28.10. Escrevendo arquivos com FileOutputStream
28.12. Lendo arquivos de texto com FileReader
28.13. Escrevendo arquivos de texto com FileWriter
28.14. Lendo arquivos texto de forma otimizada com BufferedReader
28.15. Escrevendo arquivos texto de forma otimizada com BufferedWriter
28.16. Reconhecendo a API de IO em System.in e Scanner
28.17. Reconhecendo a API de IO em System.out e a classe PrintStream
28.18. Desafio - API clássica de IO
29.02. Representando arquivos e pastas com a classe Path
29.03. Trabalhando com caminhos absolutos e relativos
29.04. Operações básicas com a classe Files
29.05. Copiando arquivos e diretórios
29.06. Movendo arquivos e diretórios
29.07. Excluindo arquivos e diretórios
29.08. Realizando operações com Files.walkFileTree
29.09. Obtendo informações de arquivos e diretórios
29.10. Listando conteúdo de diretórios
29.11. Pesquisando arquivos em uma pasta e subpastas
29.12. Entendendo os buffers e usando ByteBuffer
29.14. Decodificando ByteBuffer em CharBuffer
29.15. Lendo arquivos com ByteChannel
29.16. Lendo arquivos com buffers menores
29.17. Escrevendo arquivos com ByteChannel
29.18. Usando a API de IO clássica com implementações da NIO
29.19. Simplificando a leitura de arquivos com a classe Files
29.20. Simplificando a escrita de arquivos com a classe Files
30.02. Tornando classes serializáveis com a interface Serializable
30.03. Serializando objetos com ObjectOutputStream
30.04. Desserializando objetos com ObjectInputStream
30.05. Ignorando propriedades com transient
30.06. Entendendo e gerando serialVersionUID
30.08. Desafio - serialização de objetos
31.02. Gerando arquivos JAR como bibliotecas
31.03. Importando arquivos JAR no projeto
31.04. Usando bibliotecas terceiras
31.05. Gerando arquivos JAR executáveis
31.09. Criando um projeto Maven com IntelliJ IDEA
31.11. Entendendo o Standard Directory Layout
31.14. Instalando e adicionando dependências com Maven
31.15. Usando dependência do Maven Central Repository
31.16. Entendendo as dependências transitivas
31.17. Entendendo os plugins do Maven e o Super POM
31.18. Gerando Fat JAR com Maven Assembly Plugin
32.01. Por que fazer logging
32.03. Usando o Java Logging API (JUL)
32.04. Conhecendo os níveis de log do JUL
32.05. Registrando um log de exceção com JUL
32.06. Criando logging.properties e configurando nível de log
32.07. Salvando logs em arquivos com FileHandler do JUL
32.08. Usando a Java Logging API com SLF4J
32.09. Usando o Logback com SLF4J
32.11. Configurando a saída de logs com logback.xml
32.12. Customizando mais o padrão de layout do Encoder
32.13. Salvando logs em arquivos com FileAppender do Logback
32.14. Desafio - Logback e SLF4J
33.06. Adicionando driver JDBC ao projeto e criando uma conexão
33.07. Executando consultas SQL com Statement
33.08. Realizando consultas SQL com a cláusula where
33.09. Executando consultas SQL com PreparedStatement
33.10. Executando comandos que alteram dados (DML)
33.11. Obtendo código de autoincremento gerado
33.12. Gerenciando transações com o banco de dados
34.02. Criando entidade e camada de serviço
34.04. Implementando uma classe Repository
34.05. Implementando uma consulta no repositório
34.06. Desacoplando a conexão com o banco de dados
34.07. Implementando uma fábrica de Repository
34.08. Desacoplando a implementação de Repository
34.09. Alternando a implementação do Repository
34.10. Abstraindo a fábrica de repositórios
34.11. Criando um arquivo de configuração (properties)
35.01. Conhecendo o projeto de gerador de CSV
35.02. Lendo propriedades dinamicamente com Reflection API
35.03. Invocando a leitura de valores de propriedades
35.05. Criando uma anotação customizada
35.06. Processando anotações com Reflection API
35.07. Adicionando e processando atributos na anotação
Folders and files Name Name Last commit message
Last commit date
parent directory Jun 12, 2022
Jun 12, 2022
View all files
You can’t perform that action at this time.
