Dominando os Fundamentos de Java: Do "Hello World" à Qualidade de Código Profissional
Olá, comunidade DIO!
Quem navega pelas vagas de tecnologia sabe: Java continua sendo um pilar em posições de backend, QA automation, microsserviços e até em projetos de nuvem e mensageria. Mostrar que você domina os fundamentos não é apenas sobre sintaxe, mas sobre passar a mensagem de que consegue entrar em um código legado, entender o que está acontecendo e contribuir com qualidade.
Um ponto forte de Java é a combinação de orientação a objetos, tipagem forte e um ecossistema maduro. Isso ajuda tanto quem está começando quanto quem quer crescer como dev ou QA, porque facilita a criação de código testável e a manutenção de projetos grandes em equipe.
Estrutura Básica: O Ponto de Partida de Todo Dev Java
Começamos pelo clássico, mas já com uma visão de quem pensa em código limpo e organizado.
java
public class HelloDio {
public static void main(String[] args) {
System.out.println("Olá, comunidade DIO!");
}
}
Aqui já destacamos fundamentos cruciais:
public class HelloDio: A definição de uma classe pública, que segue a convenção de nomenclatura PascalCase, essencial para a legibilidade.public static void main(String[] args): O ponto de entrada da aplicação, o método que a JVM (Java Virtual Machine) procura para iniciar o programa.System.out.println(...): Uma saída padrão, útil para logs simples e depuração inicial.
Claro, esse é apenas o ponto de partida. No dia a dia de um projeto real, raramente paramos em um Hello World, mas entender essa estrutura é a base para construir as classes complexas que resolvem problemas de negócio.
Trabalhando com Tipos e Variáveis
Java é uma linguagem fortemente tipada, o que significa que a escolha do tipo de dado impacta diretamente a performance e o uso de memória. Usar nomes de variáveis descritivos, como quantidadeUsuarios, não é apenas uma boa prática: é essencial para a manutenção e para facilitar os testes.
java
public class TiposBasicos {
public static void main(String[] args) {
int quantidadeUsuarios = 150;
double taxaConversao = 3.7;
boolean recursoAtivo = true;
char tipoPlano = 'A';
System.out.println("Usuários: " + quantidadeUsuarios);
System.out.println("Taxa de conversão: " + taxaConversao + "%");
System.out.println("Recurso ativo? " + recursoAtivo);
System.out.println("Tipo de plano: " + tipoPlano);
}
}
Em projetos reais, esses valores raramente são fixos no código (hardcoded). Eles são dinâmicos, vindos de bancos de dados, respostas de APIs ou arquivos de configuração, e o uso de tipos primitivos (int, double, boolean) ajuda a garantir a eficiência.
Orientação a Objetos na Prática
Em vez de apenas listar os quatro pilares da POO, vamos ver como eles se conectam com o que as empresas realmente usam.
java
public class Cliente {
private String nome;
private String email;
public Cliente(String nome, String email) {
this.nome = nome;
this.email = email;
}
public String getNome() { return nome; }
public String getEmail() { return email; }
public void atualizarEmail(String novoEmail) {
this.email = novoEmail;
}
}
java
public class ClienteService {
public void notificar(Cliente cliente, String mensagem) {
System.out.println("Enviando mensagem para " + cliente.getEmail() + ": " + mensagem);
}
}
java
public class App {
public static void main(String[] args) {
Cliente cliente = new Cliente("Ana", "ana@dio.me");
ClienteService service = new ClienteService();
service.notificar(cliente, "Bem-vinda ao seu novo projeto Java na DIO!");
}
}
Este exemplo demonstra conceitos-chave na prática. O encapsulamento protege os dados da classe Cliente, expondo-os apenas através de métodos públicos (getters e setters). Além disso, aplicamos a separação de responsabilidades, onde Cliente apenas modela os dados do domínio, enquanto ClienteService cuida da regra de negócio (a notificação). Esse tipo de modelagem é extremamente comum e se aproxima muito de como APIs REST e sistemas de back-office são construídos em projetos corporativos.
Coleções e Fluxo de Dados
Coleções aparecem em praticamente toda vaga de Java. Um exemplo simples, mas com "cara" de código de negócio, mostra que você entende como manipular conjuntos de dados.
java
import java.util.ArrayList;
import java.util.List;
public class ListaCursosDio {
public static void main(String[] args) {
List<String> cursos = new ArrayList<>();
cursos.add("Java Fundamentals");
cursos.add("Spring Boot");
cursos.add("QA Automation com Java");
cursos.add("Microsserviços na prática");
System.out.println("--- Cursos Disponíveis ---");
for (String curso : cursos) {
System.out.println(curso);
}
long cursosComJava = cursos.stream()
.filter(curso -> curso.toLowerCase().contains("java"))
.count();
System.out.println("\nTotal de cursos relacionados a Java: " + cursosComJava);
}
}
Este código destaca práticas modernas e eficientes. Usamos uma List para manter uma coleção ordenada, e o laço for-each oferece uma leitura simples. O grande destaque é o uso da Stream API (a partir do Java 8), que com filter e count permite processar a coleção de forma declarativa e elegante, algo muito valorizado no mercado.
Tratamento de Exceções com Foco em Robustez
Um bom desenvolvedor não ignora erros; ele os antecipa. O tratamento de exceções com try-catch é fundamental para criar aplicações que não "quebram" inesperadamente.
java
public class ConversorNumero {
public static void main(String[] args) {
String entrada = "123a";
try {
int numero = Integer.parseInt(entrada);
System.out.println("Número convertido: " + numero);
} catch (NumberFormatException e) {
System.err.println("Erro: A entrada '" + entrada + "' não é um número válido.");
// Em um sistema de produção, aqui chamaríamos um logger:
// log.error("Falha ao converter a entrada: {}", entrada, e);
}
}
}
Em um sistema de produção, a linha System.err.println seria substituída por uma chamada a um framework de logging (como Log4j ou SLF4J). Registrar o erro de forma estruturada é crucial para o monitoramento, depuração e análise de causa raiz em ambientes corporativos. Isso mostra a um recrutador que você pensa na saúde da aplicação a longo prazo.
