Título do artigo

Fundamentos de Java: A Base para o Desenvolvimento Moderno com Java 17+
Tag: Java
Introdução
Java é uma das linguagens de programação mais influentes e amplamente utilizadas no mundo do desenvolvimento de software. Desde seu lançamento pela Sun Microsystems em 1995, Java se consolidou como uma escolha robusta para aplicações empresariais, sistemas embarcados, Android (até recentemente), microsserviços e muito mais. Com o lançamento contínuo de novas versões — especialmente a partir do ciclo de releases semestrais iniciado em 2017 —, a linguagem evoluiu significativamente, mantendo sua essência de portabilidade, segurança e orientação a objetos.
Este artigo explora os fundamentos essenciais de Java, com foco na versão Java 17+ (LTS — Long-Term Support), que é amplamente adotada na indústria atual. Abordaremos desde a estrutura básica de um programa Java até conceitos centrais como Programação Orientada a Objetos (POO), exceções, coleções, streams e boas práticas modernas. O objetivo é fornecer uma base sólida para desenvolvedores iniciantes e reforçar conhecimentos para aqueles que desejam aprofundar-se em tecnologias como Spring Boot, testes automatizados e arquitetura de microsserviços.
1. Estrutura Básica de um Programa Java
Todo programa Java começa com uma classe. A JVM (Java Virtual Machine) executa o método main, que é o ponto de entrada da aplicação.
public class OlaMundo {
public static void main(String[] args) {
System.out.println("Olá, mundo!");
}
}
Elementos-chave:
public class: Define uma classe pública cujo nome deve corresponder ao nome do arquivo (.java).
main: Método estático obrigatório para execução.
System.out.println: Imprime uma mensagem no console.
A partir do Java 21, é possível usar "Hello World" sem classe (com Implicit Classes), mas para fins educacionais e compatibilidade com Java 17+, mantemos a estrutura clássica.
2. Tipos de Dados e Variáveis
Java é uma linguagem estaticamente tipada, o que significa que o tipo de uma variável deve ser declarado explicitamente.
Tipos primitivos:
Inteiros: byte, short, int, long
Ponto flutuante: float, double
Caractere: char
Lógico: boolean
int idade = 25;
double salario = 5500.75;
boolean ativo = true;
char inicial = 'J';
Wrapper Classes
Cada tipo primitivo tem uma classe equivalente (ex: Integer, Double, Boolean), usada em coleções e recursos como autoboxing.
3. Controle de Fluxo
Estruturas condicionais e de repetição são essenciais para lógica de programação.
Condicionais:
if (idade >= 18) {
System.out.println("Maior de idade");
} else {
System.out.println("Menor de idade");
}
Laços:
for (int i = 0; i < 5; i++) {
System.out.println("Iteração: " + i);
}
while (ativo) {
// executa enquanto ativo for true
}
A partir do Java 14, o switch suporta expressões e pattern matching (em versões mais recentes), mas em Java 17, já é possível usar a sintaxe moderna:
String dia = switch (numeroDia) {
case 1 -> "Domingo";
case 2 -> "Segunda";
default -> "Dia inválido";
};
4. Programação Orientada a Objetos (POO)
Java é uma linguagem puramente orientada a objetos (exceto pelos tipos primitivos). Os quatro pilares da POO são:
4.1. Abstração
Esconder detalhes complexos e expor apenas o necessário. Exemplo: uma classe ContaBancaria expõe métodos como depositar() e sacar(), sem revelar a lógica interna.
4.2. Encapsulamento
Proteger os dados internos de uma classe usando modificadores de acesso (private, protected, public).
public class Pessoa {
private String nome;
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
4.3. Herança
Permite que uma classe herde atributos e métodos de outra.
class Animal {
void emitirSom() {
System.out.println("Som genérico");
}
}
class Cachorro extends Animal {
@Override
void emitirSom() {
System.out.println("Au au!");
}
}
4.4. Polimorfismo
Um objeto pode ser tratado como instância de sua classe ou de uma superclasse.
Animal meuPet = new Cachorro();
meuPet.emitirSom(); // Saída: "Au au!"
5. Tratamento de Exceções
Java utiliza um sistema robusto de tratamento de erros com try-catch-finally e exceções verificadas/não verificadas.
try {
int resultado = 10 / 0;
} catch (ArithmeticException e) {
System.err.println("Erro: divisão por zero!");
} finally {
System.out.println("Bloco finally sempre executa.");
}
A partir do Java 7, é possível usar multi-catch:
catch (IOException | SQLException e) {
// trata ambas as exceções
}
6. Coleções e Streams (Java 8+)
As coleções (List, Set, Map) são fundamentais para manipulação de dados.
Exemplo com List:
List<String> linguagens = new ArrayList<>();
linguagens.add("Java");
linguagens.add("Python");
Streams (Java 8+)
Permite processamento funcional de coleções:
List<String> filtradas = linguagens.stream()
.filter(l -> l.startsWith("J"))
.collect(Collectors.toList());
Em Java 17, os Records (introduzidos no Java 14 e estabilizados) simplificam a criação de classes de dados imutáveis:
public record Pessoa(String nome, int idade) {}
7. Modularidade com o Java Platform Module System (JPMS)
Introduzido no Java 9, o sistema de módulos permite criar aplicações mais seguras e eficientes. Um módulo é definido por um arquivo module-info.java:
module meu.app {
requires java.base;
exports com.meuapp.servico;
}
Embora não seja obrigatório em aplicações pequenas, é essencial em sistemas corporativos modernos.
8. Boas Práticas com Java 17+
Use var com moderação (Java 10+):
var nome = "João"; // inferência de tipo
Funciona apenas em escopo local.
Prefira interfaces funcionais (Supplier, Consumer, Function) para código limpo.
Optional<String> valor = Optional.ofNullable(getString());
valor.ifPresent(System.out::println);
Teste seu código: Utilize JUnit 5 e Mockito para testes unitários e de integração.
9. Preparando-se para o Ecossistema Spring Boot
Com os fundamentos sólidos em Java, o próximo passo natural é explorar o Spring Boot, que simplifica o desenvolvimento de aplicações RESTful, microsserviços e sistemas com segurança (Spring Security), autenticação JWT, documentação (Swagger/OpenAPI) e containerização (Docker).
Por exemplo, um controlador REST básico em Spring Boot depende diretamente do entendimento de:
Anotações (@RestController, @GetMapping)
Injeção de dependência
Tratamento de exceções globais
Serialização JSON (Jackson)
Tudo isso parte dos fundamentos que discutimos aqui.
Conclusão
Dominar os fundamentos de Java é o primeiro e mais importante passo para se tornar um desenvolvedor eficaz no ecossistema Java moderno. Com Java 17 — uma versão LTS amplamente suportada —, você tem acesso a recursos poderosos como Records, Pattern Matching para instanceof, Text Blocks, além de melhorias de desempenho e segurança.
Ao internalizar conceitos como POO, exceções, coleções, streams e boas práticas de código limpo, você estará preparado não apenas para escrever programas funcionais, mas para construir sistemas escaláveis, testáveis e manuteníveis — exatamente o que o mercado exige de um desenvolvedor júnior em evolução para pleno.
Continue praticando, lendo a documentação oficial da Oracle/OpenJDK, contribuindo com projetos open source e escrevendo testes. A jornada com Java é longa, mas extremamente recompensadora.
Referências
Oracle. (2025). Java SE 17 Documentation. Disponível em: https://docs.oracle.com/en/java/javase/17/
Goetz, B. et al. (2005). Java Concurrency in Practice. Addison-Wesley.
Bloch, J. (2018). Effective Java (3ª ed.). Addison-Wesley.
OpenJDK. (2025). JEP Index – Java Enhancement Proposals. Disponível em: https://openjdk.org/jeps/
DIO. (2025). Trilha de Formação Java. Disponível em: https://web.dio.me/