1. A palavra-chave var
Quando começamos a escrever código em Java, nos deparamos com um sistema de tipos rigoroso: cada variável precisa ser declarada explicitamente — informar seu tipo. Isso é útil para a confiabilidade, mas às vezes as declarações ficam prolixas e sobrecarregam o código. Para facilitar a vida, o Java adicionou uma ferramenta prática — inferência de tipo (var).
var permite escrever um código mais curto e limpo, sem sacrificar a segurança de tipos: você escreve o valor, e o compilador infere o tipo automaticamente.
Exemplo
var age = 23; // o compilador determinará o tipo do número 23 e substituirá por int age
var name = "Ana"; // o compilador determinará o tipo de "Ana" e substituirá por String name
var price = 99.99; // o compilador determinará o tipo 99.99 e substituirá por double price
Por que surgiu o var?
- Legibilidade: não é preciso escrever tipos longos (como HashMap<String, List<Integer>>) manualmente.
- Flexibilidade: permite mudar os tipos com mais facilidade no futuro: corrigiu à direita — à esquerda o var já se ajusta.
- Estilo moderno: praticamente todos os projetos Java modernos usam var quando o tipo fica claro a partir da inicialização.
Quando é possível (e recomendável) usar var
- Quando o tipo da variável fica inequivocamente claro pelo lado direito.
- Quando o tipo é óbvio (var price = 100; — está claro que é int).
- Quando o tipo é muito longo ou complexo (por exemplo, HashMap<Integer, List<Calendar>>).
Exemplo com array
var numbers = new int[] { 1, 2, 3, 4 };
Exemplo com método
var input = console.nextLine(); // input — é String (o método retorna String)
Quando é melhor NÃO usar var
Se o tipo não for claro pelo lado direito, o código pode ficar menos compreensível. Se em um mês você mesmo não entender qual é o tipo ali, é melhor indicar explicitamente.
var mystery = DoSomethingVeryComplicated(); // QUEM É VOCÊ, mystery???
Aqui é melhor declarar o tipo explicitamente:
String result = DoSomethingVeryComplicated();
Regra de ouro: use var somente onde ele não prejudica a legibilidade!
var — apenas para variáveis locais
A palavra-chave var funciona apenas para variáveis locais — dentro de métodos. Não é possível usar var para:
- parâmetros de método;
- campos de classe;
- constantes.
Como o var funciona “por baixo do capô”
- O compilador Java, durante a compilação, substitui pelo tipo correto.
- Depois da compilação não resta nenhum var.
- Não há perda de desempenho: é apenas uma conveniência para o programador.
var year = 2025; // na fase de compilação vira: int year = 2025;
Erros típicos ao usar var
Variável não inicializada:
var a; // ERRO: o compilador não tem de onde inferir o tipo!
Inicialização ambígua:
var list = null; // ERRO: o tipo de null não está definido!
Reutilização da variável com tipos diferentes:
var value = 5; // value — int
value = "Cinco"; // ERRO: value já é int!
Comparação: tipos explícitos e var
| Cenário | Tipo explícito | var |
|---|---|---|
| Tipo inequívoco | |
|
| Método retorna um tipo complexo | |
|
| Array | |
|
2. A palavra‑chave final: declaração de constantes
Constante é uma variável cujo valor não pode ser alterado após a inicialização. Constantes tornam o código mais confiável, claro e protegem contra alterações acidentais de números e strings importantes.
- Número pi (PI = 3.14159…)
- Quantidade máxima de usuários (MAX_USERS = 1000)
- Nome da empresa (COMPANY_NAME = "CodeGym")
No Java, para declarar uma constante usa-se o modificador final. Ele diz ao compilador: “depois da primeira atribuição — não pode mais alterar!”
final Tip IMYA_KONSTANTY = znachenie;
Sintaxe
final int DAYS_IN_WEEK = 7;
final double PI = 3.1415926535;
final String GREETING = "Olá, Java!";
Pontos importantes:
- Uma variável com final deve ser inicializada (imediatamente ou no construtor — se for um campo da classe).
- Tentar alterar o valor resultará em erro de compilação.
Exemplo: não é possível alterar uma variável final
final int MAX_USERS = 100;
MAX_USERS = 200; // Erro: não é possível atribuir um novo valor a uma variável final
Comentário: se você descomentar a atribuição, o projeto não será compilado.
3. static final: constantes no nível da classe
No Java, muitas vezes precisamos de constantes que não dependem de um objeto específico — “comuns” a toda a classe. Para isso, usa-se a combinação static + final.
Por que static final?
- static — a variável pertence à classe (uma para todos).
- final — o valor não pode ser alterado.
Sintaxe
public static final double PI = 3.1415926535;
public static final int MAX_USERS = 1000;
public static final String COMPANY_NAME = "CodeGym";
Onde declarar? Normalmente — no início da classe (antes dos métodos).
Exemplo de uso na classe
public class MathUtils
{
public static final double PI = 3.1415926535;
public static double circleLength(double radius)
{
return 2 * PI * radius;
}
}
Chamada:
double len = MathUtils.circleLength(5);
System.out.println(len); // 31.4159...
Observe: acessamos a constante pelo nome da classe: MathUtils.PI.
4. Diferença entre apenas final e static final
final — o valor do campo não pode ser alterado após a inicialização, mas cada objeto tem seu próprio valor.
static final — uma única constante para toda a classe, não depende de objetos.
Exemplo: diferença na prática
public class User
{
public final String name; // Cada User tem seu próprio nome (final)
public static final String COMPANY = "CodeGym"; // Uma empresa para todos (static final)
public User(String name)
{
this.name = name;
}
}
User u1 = new User("Vasya");
User u2 = new User("Petya");
System.out.println(u1.name); // Vasya
System.out.println(u2.name); // Petya
System.out.println(User.COMPANY); // CodeGym
Conclusão: name — campo individual imutável, COMPANY — constante comum.
Convenções de nomenclatura de constantes
É comum nomear constantes com LETRAS_MAIÚSCULAS_SEPARADAS_POR_UNDERSCORE.
public static final int MAX_USERS = 1000;
public static final double GRAVITY = 9.81;
public static final String DEFAULT_GREETING = "Hello, world!";
Dica: viu um nome assim — não tente mudar o valor no código: o compilador não vai permitir.
5. Prática: declaração e uso de constantes
Exemplo: classe com constantes
public class CircleCalculator
{
public static final double PI = 3.1415926535;
public static double getLength(double radius)
{
return 2 * PI * radius;
}
public static double getArea(double radius)
{
return PI * radius * radius;
}
}
Uso:
public class Main
{
public static void main(String[] args)
{
double r = 5.0;
System.out.println("Comprimento da circunferência: " + CircleCalculator.getLength(r));
System.out.println("Área do círculo: " + CircleCalculator.getArea(r));
}
}
Resultado:
Comprimento da circunferência: 31.415926535
Área do círculo: 78.5398163375
Tentativa de alterar a constante
CircleCalculator.PI = 3.14; // Erro de compilação: cannot assign a value to final variable PI
6. Particularidades e nuances
Constantes para objetos
É possível declarar final para referências a objetos, mas isso não torna o objeto imutável! Isso apenas impede atribuir outra referência à variável.
final StringBuilder sb = new StringBuilder("Hello");
sb = new StringBuilder("World"); // Erro: não é possível atribuir um novo objeto
sb.append(", Java!"); // Permitido — o estado do objeto é que muda
System.out.println(sb); // Hello, Java!
Conclusão: final protege a referência, não o objeto. Para verdadeira imutabilidade, use classes imutáveis (por exemplo, String, List.of() etc.).
Uso de constantes em vez de “números mágicos”
Mau estilo:
double area = 3.1415 * r * r; // O que é 3.1415? Por que exatamente esse número?
Bom estilo:
double area = PI * r * r; // Fica claro que é usado o número pi
7. Erros típicos ao trabalhar com constantes e var
Erro nº 1: tentativa de alterar o valor de uma variável final. Se a variável for declarada com final, uma reatribuição resultará em erro de compilação.
Erro nº 2: tentativa de declarar uma constante com var. Para constantes, sempre use um tipo explícito junto com final ou static final. var — apenas para variáveis locais.
Erro nº 3: nomenclatura incorreta de constantes. Constantes devem ser escritas com LETRAS_MAIÚSCULAS_SEPARADAS_POR_UNDERSCORE. Algo como final int maxUsers = 100; prejudica a legibilidade.
Erro nº 4: esquecer o escopo. Uma constante declarada dentro de um método é visível apenas nele. Para uso em toda a classe, declare no nível da classe como static final.
Erro nº 5: achar que final torna o objeto imutável. final fixa a referência, não o estado do objeto — são coisas diferentes.
GO TO FULL VERSION