Primeiros passos com Java: Guia de boas práticas
Introdução
No mundo da programação existem diversas linguagens de programação, entre elas, uma das mais utilizadas e queridas pelos programadores é a linguagem Java. Isso se deve pois é uma linguagem com alta portabilidade e sua construção é baseada nos principios programação orientada a objetos (POO). Uma vez escrito o código, ele pode ser executado em qualquer sistema operacional sem a necessidade de ser reescrito, o que garante independência de plataforma, já que o Java é compilado para um formato intermediário chamado bytecode, interpretado pela JVM (Java Virtual Machine).
O objetivo deste artigo é incentivar novos programadores a explorarem o potencial da linguagem Java em seus projetos e apresentar as principais boas práticas para iniciar com segurança e eficiência nessa tecnologia tão poderosa e versátil. Hoje, o Java está presente em diversos segmentos da tecnologia, desde o desenvolvimento de jogos e aplicações em nuvem, até soluções de big data, inteligência artificial e dispositivos IoT (Internet das Coisas) — um verdadeiro testemunho de sua robustez e relevância no mundo moderno da programação.
1 - Por quê utilizar Java?
Dentre as principais vantagens de utilizar a linguagem Java, podemos citar:
- Linguagem robusta, confiável, segura e simples;
- Pode ser utilizada para desenvolver todo tipo de aplicação, desde aplicativos corporativos até sistemas em nuvem;
- Independencia de plataforma, podendo funcionar em diferentes sistemas operacionais;
- Gerenciamento automático de memória.
Conforme mencionado, sua segurança, confiabilidade e desempenho são os principais motivos para escolher esta linguagem ao desenvolver um projeto, seja ele de pequeno, médio ou grande porte, pois é uma linguagem altamente escalável. Além disso, a linguagem está em constante evolução, seguindo as melhores boas práticas do mercado.
2 - Boas práticas para iniciantes em Java
Para ter um bom código, é necessário utilizar algumas técnicas de boas práticas, deve-se pensar como um desenvolvedor Java, não apenas codar.
Começaremos citando a organização dos arquivos, um arquivo é constituído por seções, divididas por linhas em branco, com pequenos comentários identificando o que cada seção daquele código, além disso, arquivos com mais de 2000 linhas devem ser evitados, pois são muito pesados.
Todos os arquivos de origem devem iniciar com um comentário no estilo C que informe o nome da classe, informações da versão, data e aviso de direitos autorais, conforme demonstrado abaixo:
/*
* Classname
*
* Version information
*
* Date
*
* Copyright notice
*/
Após o comentário declarando as informações do arquivo, encontramos as declarações de packages, seguido por uma linha em branco e o inicio do código, contendo um comentário de documentação da classe, seguido do prefixo 'class', a variável da classe (como 'static'/''public') e abaixo disso se constrói os construtores e métodos da classe.
Além disso, temos também que nos atentar a estrutura do projeto, o arquivo principal de execução sempre deve estar na pasta src, enquanto os demais arquivos de classes, devem estar em subpastas separadas, conforme demonstrado na estrutura de diretórios abaixo:
/meuprojeto
└── /src
├── /com/meuprojeto/veiculos
│ ├── Veiculo.java
│ └── Carro.java
└── Main.java
Dentro do nosso projeto, temos o arquivo Veiculo.java, que é escrito da seguinte maneira, seguindo as boas práticas de codificação:
package com.meuprojeto.veiculos;
/**
* Interface que representa um veículo.
* Define o contrato básico que qualquer veículo deve seguir.
*
* @author [seu nome]
* @version 1.0
*/
public interface Veiculo {
/**
* Exibe o tipo de veículo e sua informação básica.
*/
void exibirInformacoes();
}
Já no arquivo principal (Main.java), temos o seguinte código:
// Importa a classe Carro do pacote com.meuprojeto.veiculos
import com.meuprojeto.veiculos.Carro;
public class Main {
public static void main(String[] args) {
// Criação de um objeto Carro usando o construtor parametrizado
Carro meuCarro = new Carro("Toyota", "Corolla", 2023);
meuCarro.exibirInformacoes();
System.out.println("---");
// Criação de outro objeto Carro usando o construtor padrão
Carro outroCarro = new Carro();
outroCarro.setMarca("Honda");
outroCarro.setModelo("Civic");
// A interface é implícita, então não precisamos importá-la
outroCarro.exibirInformacoes();
System.out.println("---");
// Acessando a variável estática para contar quantos carros foram criados
System.out.println("Total de carros criados: " + Carro.numeroDeCarros);
}
}
É imprenscindivel citarmos as regras de identação do código, devem ser utilizados quatro espaços de recuo, e as linhas não devem conter mais que 80 caracteres, pois após isso podem não ser processadas corretamente por muitos terminais ou ferramentas.
Quando uma expressão não couber em uma única linha, o desenvolvedor deve dividi-la seguindo os seguintes princípios:
- Quebra após uma vírgula.
- Pausa antes de um operador.
- Prefira intervalos de nível mais alto.
- Alinhe a nova linha com o início da expressão no mesmo nível da linha anterior.
3 - Convenções de nomenclatura
Ao desenvolver um código, é muito importante se atentar nas nomenclaturas das classes, métodos e até mesmo arquivos, para que seja de fácil entendimento e possua uma verdadeira abstração do mundo real, principalmente quando falamos sobre programação orientada a objetos.
Robert C. Martin, autor do livro Clean Code, enfatiza a importância das convenções de nomenclatura na seguinte citação:
"Um nome descritivo longo é melhor do que um nome enigmático curto. Um nome descritivo longo é melhor do que um comentário descritivo longo"
Em Java, existe um conjunto de regras a serem seguidas ao nomear qualquer coisa. Um nome bem formado ajuda na leitura do código, como também transmite qual a intenção daquele código, abaixo seguem exemplos de como devemos lidar com as nomenclaturas em Java.
Classes:
Se tratando de programação orientada a objetos, é um modelo para objetos que frequentemente representam objetos do mundo real. Logo, devemos usar substantivos para nomear classes que as descrevam corretamente.
// Classe representando um abajur (objeto do mundo real)
public class Abajur {}
Variáveis:
As variáveis em Java capturam o estado do objeto criado a partir de uma classe, ou seja, armazenam os valores dos atributos que definem as características únicas de cada instância.
// Classe representando um abajur (objeto do mundo real)
public class Abajur {
// Variáveis de instância que definem o estado de cada objeto Abajur
public string abajurTamanho;
private string abajurValor;
}
Métodos:
Estes sempre fazem parte de classes, e geralmente representam uma ação sobre o estado de cada objeto criado a partir da classe. Portanto, é necessário nomea-los utilizando verbos.
// Classe representando um abajur (objeto do mundo real)
public class Abajur {
// Variáveis de instância que definem o estado de cada objeto Abajur
public string abajurTamanho;
private double abajurValor;
private boolean estaLigado;
}
/**
* Construtor para inicializar o objeto Abajur
*/
public Abajur(String tamanho, double valor) {
this.abajurTamanho = tamanho;
this.abajurValor = valor;
this.estaLigado = false; // Por padrão, o abajur inicia desligado.
}
/**
* Método que define o comportamento de ligar o abajur.
*/
public void ligarAbajur(){
this.estaLigado = true;
System.out.println("O abajur foi ligado.");
}
/**
* Método que define o comportamento de desligar o abajur.
*/
public void desligarAbajur(){
this.estaLigado = false;
System.out.println("O abajur foi desligado.");
}
/**
* Método para exibir o estado atual do abajur.
*/
public void exibirEstado(){
System.out.println("Tamanho do abajur: " + this.abajurTamanho);
System.out.println("Valor do abajur: " + this.abajurValor)
System.out.println("Status: " + (this.estaLigado ? "Ligado" : "Desligado"));
}
}
Ainda que tenhamos focado em como escolher um nome para um identificador em Java, é importante lembrar que existem outras boas práticas, como usar camel case, que ajudam na legibilidade. Além disso, existem outras normas para nomear interfaces, enumerações e constantes.
4 - Clean Code
Antes de partir para os detalhes de como funciona o método Clean Code, vamos entender sobre o que se trata. Cada linguagem de programção possui seu próprio conjunto de peculiaridades e especificidades, mas para que todos possam entender o código, é importante aplicar o conceito informado.
Clean Code nada mais é do que um código limpo, onde qualquer desenvolvedor pode ler e alterar com facilidade. De acordo com Martin Fowler:
"Qualquer tolo consegue escrever código que um computador entenda. Bons programadores escrevem código que humanos conseguem entender."
Códigos escritos com base no princípio de clean code possuem diversas características, dentre elas podemos citar três muito importantes:
- Foco: Um código deve ser escrito para resolver um problema específico. Ele não deve realizar nenhuma ação que não tenha relação com aquele problema em questão. Isso se aplica em metódos, classes, pacotes ou módulos.
- Simplicidade: É a característica mais importante deste conceito, e geralmente ignorada pelos desenvolvedores. O código deve ser limpo e simples, pois o aumento da complexidade de um código pode acarretar em erros e o torna mais difícil de ler e manter.
- Testabilidade: Um código simples e limpo deve ser capaz de resolver um problema específico, deve ser intuitivo e fácil de testar a base do código, de preferência, de forma automatizada.
Ao iniciar a codificação com esses conceitos em mente, o desenvolvedor economiza tempo e trabalho pois depois não irá precisar refatorar o código.
Seguindo a linha de raciocínio, podemos dizer que o código abaixo segue os padrões de clean code:
import com.meuprojeto.formas.Forma;
//Não precisamos importar a classe Circulo, pois ela está no mesmo pacote
//e pode ser acessada através da interface
public class Main {
public static void main(String[] args) {
//Declara uma variável do tipo da interface
Forma meuCirculo = new Circulo(5.0);
//Chama o método da interface
double area = meuCirculo.calcularArea();
System.out.println("A área do círculo é: " + area);
}
}
O código conta com as seguintes características:
- Funções curtas e com uma responsabilidade: o método "calcularArea()" faz apenas uma atividade, o que torna o código fácil de ler, entender e testar.
- Encapsulamento: o raio (private double raio) é uma váriavel de instância que não pode ser acessada diretamente por outras classes, apenas através do construtor, protegendo a integridade do objeto.
- Acomplamento baixo: o código Main depende apenas da interface Forma para chamar o método calcularArea(). O que significa que é possível trocar a implementação sem precisar mudar o código da classe Main.
5 - Erros comuns e como evitá-los
Aprender Java pode se tornar bem desafiador caso você não aprenda os conceitos e técnicas básicas para codificar. Muitos iniciantes cometem erros que podem gerar frustração e até desmotivar o desenvolvedor, até mesmo nos códigos mais simples. Abaixo iremos detalhar um pouco melhor os principais erros de principiante.
Erros de Sintaxe:
Estes são os mais simples de se identificar pelo compilador
Exemplos:
System.out.println("Hello world!")
- Erro: falta de ponto e vírgula no final da linha
- Como evitar: sempre revisar se cada comando termina com ponto e vírgula
public class Main {
public static void main(String[] args {
System.out.println("Hello World!");
}
}
- Erro: parêntese não fechado no método main.
- Como evitar: contar parênteses, chaves e colchetes. (as IDEs geralmente colorem para ficar de fácil leitura)
Tipos de Dados
Esses erros ocorrem quando você tenta atribuir ou manipular valores incompatíveis.
Exemplos:
int idade = "25";
- Erro: não é possível atribuir uma String a um int
- Como evitar: conferir o tipo de cada variável e caso necessário, utilizar uma conversão
double salario = 2000;
int salarioInt = salario;
- Erro: tentar colocar double em int sem uma conversão
- Como evitar: fazer um cast explícito: int salarioInt = (int) salario;
Escopo de variáveis
Este tipo de erro acontece quando a variável é utilizada fora do local em que foi declarada.
Exemplo:
public class Main {
public static void main(String[] args) {
if(true) {
int x = 10;
}
System.out.println(x); // erro: x não existe aqui
}
}
- Erro: a variável x só existe dentro do bloco if
- Como evitar: caso seja necessário utilizar fora do escopo, declare como uma variável global
Uso incorreto de operadores
Um erro muito comum ao codificar é confundir os operadores de atribuição e comparação.
Exemplo:
int a = 5;
if(a = 10) {
System.out.println("Igual!");
}
- Erro: = atribui valor e não realiza comparação.
- Como evitar: usar == para comparar valores -> if(a == 10)
String s1 = "Hello";
String s2 = "World";
if(s1 == s2) {
System.out.println("Iguais!");
}
- Erro: == compara referência, não conteúdo de objetos.
- Como evitar: usar s1.equals(s2) para comparar Strings.
Conclusão
Atualmente a linguagem Java continua sendo uma das mais relevantes no cenário da programação moderna, justamente por sua alta portabilidade, robustez e capacidade de escalabilidade, além disso possui uma ampla comunidade ativa para suporte e discussões. No entando, para aproveitar todo o potencial que a linguagem oferece, é essencial adotar boas práticas desde o início da codificação, como a organização adequada do código, o uso correto das nomenclaturas e a aplicação dos princípios de Clean Code.
Além disso, conhecer e compreender os erros mais comuns, desde erros de sintaxe até erros de escopo, são passos fundamentais para aprimorar sua lógica e clareza no código. Evitar esses erros iniciais não apenas melhora a qualidade técnica do software que está sendo desenvolvido, mas também aprimora a mentalidade crítica necessária para evoluir como programador.
Em resumo, aprender a linguagem Java vai muito além de apenas domínio de sintaxe: trata-se de compreender o contexto, a importância da legibilidade, da manutenção e da responsabilidade em cada linha escrita. Com disciplina e boas práticas, é possível transformar simples trechos de código em soluções eficientes, elegantes e duradouras.
E você, já utiliza das técnicas e princípios de boas práticas da programação?
Referências
BLOCH, Joshua. Effective Java. 3. ed. Addison-Wesley, 2018.
DEITEL, Paul; DEITEL, Harvey. Java: How to Program. 11. ed. Pearson, 2017.
MARTIN, Robert C. Clean Code: A Handbook of Agile Software Craftsmanship. Prentice Hall, 2008.
ORACLE. Java Technologies. Disponível em: https://www.oracle.com/java/technologies/. Acesso em: 16 out. 2025.
ORACLE. The Java™ Tutorials. Disponível em: https://docs.oracle.com/javase/tutorial/getStarted/. Acesso em: 16 out. 2025.
ORACLE. Java Language and Virtual Machine Specifications. Disponível em: https://docs.oracle.com/javase/specs/. Acesso em: 16 out. 2025.
BAELDUNG. Java Clean Code. Disponível em: https://www.baeldung.com/java-clean-code. Acesso em: 16 out. 2025.
W3SCHOOLS. Java Tutorial. Disponível em: https://www.w3schools.com/java/. Acesso em: 16 out. 2025.
AMAZON WEB SERVICES. O que é Java?. Disponível em: https://aws.amazon.com/pt/what-is/java/. Acesso em: 16 out. 2025.
