JAVA

● Função da palavra final:

○ Variáveis: Não podem ser modificadas após a atribuição.

○ Métodos: Não podem ser sobrescritos.

○ Classes: Não podem ser estendidas.

● Função da palavra static:

○ Variáveis static: Compartilhadas por todas as instâncias da classe.

○ Métodos static: Podem ser chamados sem instanciar a classe.

○ Blocos static: Executam quando a classe é carregada.

○ Classes static: Podem ser usadas sem uma instância da classe externa.

1. Fundamentos da Linguagem
● Tipos de dados, variáveis, operadores, loops (for, while), condicionais (if, switch).

● Estruturas de controle e sintaxe básica do Java.

2. Programação Orientada a Objetos (POO)

● Conceitos: Classe, objeto, herança, polimorfismo, encapsulamento, abstração.

● Sobrescrita e Sobrecarga de Métodos: Diferenças e uso.

● Modificadores de Acesso: private, protected, public, default.

3. Coleções (Collections)
● Conhecimento de List, Set, Map, Queue.

● Diferenças entre as implementações, como ArrayList, LinkedList, HashSet, HashMap.

4. Tratamento de Exceções
● Usar try-catch, finally, e exceções customizadas.

● Diferença entre exceções verificadas e não verificadas.

5. Threads e Concorrência
 ● Noções básicas sobre Thread, Runnable, synchronized, e o pacote java.util.concurrent.

6. Java 8+ Features
● Lambdas e Streams: Processamento funcional e eficiente de dados.

○ Map e Filter

● Optional: Para evitar null e tratar retornos opcionais.

● Interfaces Funcionais: Predicate, Function, Consumer, etc.

7. Gerenciamento de Memória e Garbage Collection

● Entendimento do heap, stack e como funciona o coletor de lixo (Garbage Collector).

8. Design Patterns (Padrões de Projeto)

● Familiaridade com padrões como Singleton, Factory, Observer, Strategy.

9. JVM e Performance
● Compreensão básica da arquitetura da JVM.

● Noções de otimização e profiling de código Java.

10. Banco de Dados e JDBC

● Operações básicas de banco de dados usando JDBC.

● Noção de ORM, como Hibernate ou JPA.

11. Versionamento e Maven/Gradle

● Conhecimento básico sobre como gerenciar dependências e builds com Maven ou
Gradle.

———————————

4. Tratamento de Exceções

● Exceções Verificadas vs. Não Verificadas: Exceções verificadas (checked) devem ser
tratadas ou declaradas no método, como IOException. As não verificadas (unchecked),
como NullPointerException, não precisam ser explicitamente tratadas.

● Estrutura try-catch-finally: Usada para capturar e tratar exceções. O bloco finally é

executado independentemente de uma exceção ter ocorrido ou não, útil para liberar
recursos (ex: fechar arquivos).

● Exceções Customizadas: Criação de exceções específicas para tratar erros de negócios

ou regras de aplicação, estendendo a classe Exception ou RuntimeException.
5. Threads e Concorrência

● Threads: Uma Thread é uma unidade de execução paralela. Em Java, você pode criar
threads estendendo a classe Thread ou implementando a interface Runnable.

● Concorrência: Para evitar problemas de concorrência, como condições de corrida, o

Java oferece ferramentas como synchronized para garantir o acesso ordenado a
recursos compartilhados.

● Pacote java.util.concurrent: Fornece classes como ExecutorService, Future,

CountDownLatch, facilitando a criação e controle de threads em ambientes multithread.

6. Java 8+ Features

● Lambdas: Expressões que permitem a criação de métodos anônimos de forma

concisa, tornando o código mais legível e eliminando a necessidade de classes anônimas.

● Streams: API que permite processar coleções de dados de maneira funcional e eficiente,
como filtragem, mapeamento e redução. Os Streams podem ser processados de
forma sequencial ou paralela, facilitando o processamento massivo de dados.

● Optional: Classe introduzida para lidar com valores opcionais, evitando o uso excessivo
de null e prevenindo NullPointerExceptions. Optional é utilizado para indicar que um
valor pode ou não estar presente.

7. Gerenciamento de Memória e Garbage Collection

● Heap e Stack: A memória na JVM é dividida em duas áreas principais: o heap, onde os
objetos são alocados, e o stack, onde as variáveis locais e chamadas de métodos são
gerenciadas.

● Garbage Collection (GC): Processo automático que remove objetos não utilizados da
memória para evitar vazamentos. Embora o GC seja gerenciado automaticamente, o
desenvolvedor pode otimizar o desempenho reduzindo a criação de objetos
desnecessários e entendendo o funcionamento dos coletores de lixo (ex: Mark-and-
Sweep, Generational GC).

8. Design Patterns (Padrões de Projeto)

● Padrões de projeto são soluções reutilizáveis para problemas comuns no design de

software. Alguns dos mais utilizados em Java incluem:

● Singleton: Garante que uma classe tenha apenas uma instância global.

● Factory: Encapsula a lógica de criação de objetos, delegando essa

responsabilidade para métodos de fábrica.

● Strategy: Permite que algoritmos sejam intercambiáveis em tempo de execução,

usando composição ao invés de herança.

● Observer: Define uma relação de dependência entre objetos, onde mudanças

em um objeto notificam automaticamente outros objetos.
9. JVM e Performance

● JVM (Java Virtual Machine): A JVM é responsável pela execução do bytecode Java.
Compreender seu funcionamento, como a alocação de memória (heap, stack) e os
diferentes tipos de garbage collectors, é essencial para otimizar a performance de
aplicações Java.

● Otimização de Código: Técnicas como evitar a criação excessiva de objetos, uso de

estruturas de dados eficientes, e profiling (análise de desempenho) são importantes para
melhorar o desempenho. Ferramentas como JProfiler ou VisualVM ajudam a identificar
gargalos de performance.

10. Banco de Dados e JDBC

● JDBC (Java Database Connectivity): API padrão usada para conectar e interagir com
bancos de dados relacionais em Java. Permite a execução de consultas SQL,
inserções, atualizações e exclusões diretamente no banco de dados.

● ORM (Object-Relational Mapping): Ferramentas como Hibernate ou JPA (Java

Persistence API) permitem mapear objetos Java para tabelas de banco de dados,
simplificando o acesso a dados ao automatizar as operações de banco de dados. Isso
evita a necessidade de escrever SQL diretamente.

11. Versionamento e Maven/Gradle

● Maven: Ferramenta de automação de build e gerenciamento de dependências. Utiliza

um arquivo pom.xml para configurar o projeto, especificar dependências e definir fases
de construção.

● Gradle: Outra ferramenta de build, mais moderna e flexível que o Maven, utilizando um
arquivo de configuração build.gradle baseado em scripts Groovy ou Kotlin. Gradle é
amplamente usado em projetos Android e projetos Java modernos.

● Ambas as ferramentas facilitam o gerenciamento de bibliotecas e versões de

dependências, garantindo consistência no ambiente de desenvolvimento e produção.

Java 11 x Java 17
As versões Java 11 e Java 17 trazem diversas vantagens e melhorias significativas em relação às
versões anteriores. Ambas são versões de Long-Term Support (LTS), com foco em estabilidade,
performance e novas funcionalidades.

Vantagens do Java 11 (Lançada em Setembro de 2018):

1. LTS (Long-Term Support):

○ Suporte a longo prazo, ideal para empresas que desejam uma versão estável
para ambientes de produção.
2. Novos recursos e melhorias:
 ○ Novo Garbage Collector (GC) ZGC: Um coletor de lixo escalável com pausas
extremamente curtas.
○ HTTP Client API: API para manipulação de chamadas HTTP/2, facilitando
requisições e respostas de redes assíncronas.
○ Novos métodos de Strings: Métodos como isBlank(), lines(), strip(),
entre outros, facilitam a manipulação de strings.
○ var para parâmetros de lambda: Permite o uso de var em expressões lambda.
○ Remoção de APIs e recursos obsoletos: Java 11 removeu vários recursos, como
o applet API e o JavaFX, focando em um ambiente mais enxuto e moderno.
3. Desempenho melhorado:
○ Melhorias na performance de tempo de execução com ajustes no JIT (Just-In-
Time Compiler) e garbage collection.
4. Facilidade de Deploy:
○ Introdução de ferramentas como o jlink, que permite criar uma versão do JRE
customizada e otimizada apenas com os módulos necessários para uma
aplicação específica.

Vantagens do Java 17 (Lançada em Setembro de 2021):

1. LTS (Long-Term Support):

○ Também uma versão LTS, com suporte de longo prazo, oferecendo uma
evolução sólida para as empresas que desejam atualizar do Java 11.
2. Novos Recursos da Linguagem:
○ Sealed Classes: Permite definir uma hierarquia de classes mais controlada,
restringindo quais classes podem estender uma classe ou implementar uma
interface.
○ Records: Classe imutável que facilita a criação de objetos para transportar
dados, com menos código boilerplate.
○ Pattern Matching para instanceof: Simplifica a verificação e o casting de tipos
no código.
3. Garbage Collectors Melhorados:
○ Melhoria no ZGC (coletor de lixo escalável) e no G1 para melhor uso de memória
e baixa latência.
4. Preview Features:
○ Java 17 trouxe várias features experimentais, como Pattern Matching for Switch
(correspondência de padrões no switch), que simplifica o fluxo de controle
baseado em diferentes tipos.
5. Desempenho e Segurança:
○ Melhorias de performance, segurança e suporte a containers para ambientes em
nuvem, com foco em escalabilidade.

Comparação Geral:

● Java 11 é a primeira versão LTS pós-Java 8, trazendo grandes mudanças para modernizar
o ecossistema.
● Java 17 foca em aprimorar essas inovações, com novos recursos que tornam o
desenvolvimento Java mais eficiente, seguro e fácil de manter.

Motivo para usar cada versão:

 ● Java 11 é recomendada para quem busca estabilidade em longo prazo e ainda precisa
de compatibilidade com tecnologias mais maduras.
● Java 17 é ideal para quem quer utilizar as funcionalidades mais recentes, com melhorias
substanciais de performance e novos recursos da linguagem.

Ambas as versões são LTS, garantindo suporte contínuo para aplicações corporativas em
ambientes de produção.

BOAS PRÁTICAS
○ 1. Nomes Significativos

■ Use nomes de variáveis, métodos e classes que sejam claros e

descritivos.

■ Métodos devem começar com verbos (ex: getName(),

calculateTotal()).

○ 2. Evitar Código Duplicado

■ Reutilize código sempre que possível.

■ Refatore trechos repetidos em métodos reutilizáveis.

○ 3. Seguir Convenções de Nomenclatura

■ Classes: CamelCase (ex: CustomerService).

■ Métodos e variáveis: camelCase (ex: calculateTotal).

■ Constantes: UPPER_CASE com underscores (ex: MAX_VALUE).

○ 4. Utilizar Encapsulamento

■ Declare atributos como private e forneça acesso via métodos

getter e setter.

■ Evite o uso de modificadores de acesso public em variáveis de

instância.

○ 5. Princípio da Responsabilidade Única (SRP)

■ Cada classe deve ter apenas uma responsabilidade ou motivo para

mudar.

■ Isso facilita a manutenção e testes de classes.

○ 6. Seguir o DRY (Don't Repeat Yourself)

■ Evite repetição de código.

■ Crie métodos ou classes reutilizáveis para lógicas que se repetem.

○ 7. Favor Composição sobre Herança

■ Prefira o uso de composição (objetos dentro de objetos) ao invés

de herança, a menos que exista uma clara relação "é um".

○ 8. Tratar Exceções Adequadamente

■ Sempre capture e trate exceções.

■ Evite capturar exceções genéricas (ex: Exception); prefira exceções

específicas.

■ Utilize blocos try-catch com mensagens claras.

○ 9. Minimizar Dependências Externas

■ Reduza o acoplamento entre classes.

■ Use injeção de dependência para gerenciar relacionamentos entre

objetos.

○ 10. Evitar Métodos e Classes Grandes

■ Divida métodos e classes longos em pedaços menores e mais

legíveis.

■ Cada método deve realizar apenas uma tarefa clara e bem

definida.

○ 11. Documentar o Código

■ Use comentários quando necessário para explicar lógicas

complexas.

■ Utilize a documentação Javadoc para métodos públicos e classes.

○ 12. Testar o Código (TDD e Unit Tests)

■ Escreva testes unitários para validar o comportamento de classes

e métodos.

■ Considere usar TDD (Test-Driven Development) para garantir a

qualidade do código.

○ 13. Gerenciamento Eficiente de Recursos

■ Sempre feche recursos como conexões de banco de dados,

arquivos ou streams.

■ Utilize o try-with-resources para gerenciamento automático.

○ 14. Utilizar Collections e Generics

 ■ Prefira o uso de classes da API de Collections (ex: List, Set, Map).

● List: Mantém ordem, permite duplicados.

● Set: Não permite duplicados, sem garantia de ordem

(exceto em implementações específicas).

● Map: Estrutura de chave-valor, chaves únicas.

■ Utilize generics para garantir segurança de tipos em tempo de

compilação.

○ 15. Evitar o Uso Excessivo de null

■ Sempre que possível, evite retornar ou aceitar null.

■ Considere o uso de classes como Optional para evitar

NullPointerException.

LOMBOK
● O Lombok é uma biblioteca Java que simplifica o código eliminando a
necessidade de escrever boilerplate (código repetitivo) como getters, setters,
construtores, e métodos toString(), entre outros. Ele faz isso através de
anotações que geram automaticamente o código durante a compilação.

● Lombok simplifica o código Java, eliminando a necessidade de escrever

manualmente getters, setters, construtores e métodos comuns como
toString(), equals(), etc.

● Usando anotações como @Getter, @Setter, @Data, e @Builder, ele melhora a

produtividade e legibilidade do código, gerando automaticamente essas partes
repetitivas no processo de compilação.