Clique sobre os tópicos listados abaixo para navegar até o conteúdo desejado.

  1. Variável
  2. Constante
  3. Nomeando variáves/constantes
  4. Exemplos de declarações
  5. Case-sensitive
  6. Inferência: var
  7. Optional
  8. Escopo
  9. Descarte
  10. Palavras reservadas
  11. type checking

Para escrever nossos programas na linguagem Java, precisamos saber como declarar variáveis e constantes que vão armazenar dados. Nesta parte do tutorial vamos aprender sobre variáveis, constantes e escopo dessas.

Para ver os conceitos básicos sobre variáveis e constantes visite Portugol: Variáveis e Portugol: Constantes.

O escopo de variáveis e constantes também foi discutido em Tutorial C++: Variáveis.

Sobre classes, o tópico C++: Classes pode ser conferido.

As variáveis em Java são declaradas como na sintaxe mostrada abaixo. Os tipos de dados primitivos ou classes podem ser utilizados. Para dados primitivos ou não, a sintaxe é semelhante a linguagem C++.

Sintaxe
tipo_dado nome_variavel;
Onde
tipo_dado: Tipo de dado para armazenar dados da variável 

A linguagem Java permite que essa declaração seja feita em apenas uma linha. A sintaxe é semelhante ao que foi visto no exemplo acima. Nesse tipo de declaração, os nomes das variáveis são separados por ",".

Sintaxe
tipo_dado nome_variavel1, nome_variavel2, nome_variavelN;

A atribuição de valores às variáveis é feita utilizando o operador (=), podendo ser em linha ou não.

Sintaxe
tipo_dado nome_variavel1 = valor;
tipo_dado nome_variavel1 = valor1, nome_variavel2 = valor2, nome_variavelN = valorN;
Exemplo 1
public class MyClass {
    
    public static void main(String args[]) {
    
        int a = 256;
        int b = 1,c = 2, d =2;
        int e;
    }
}
Saída
-

A linguagem Java também permite a criação de constante. Essas têm seu conteúdo preservado durante toda a execução de um programa.

Tanto a atribuição quanto a atribuição são semelhantes a declaração de variáveis. A diferença está na atribuição, que para constantes deve ser feita no momento da declaração, e o uso palavra reservada final.

Assim como variáveis, a declaração de constante seja feita em apenas uma linha.

Sintaxe
final tipo_dado NOME_CONSTANTE = valor_inicial;

final tipo_dado NOME_CONSTANTE1 = valor_inicial1, ... , NOME_CONSTANTEN = valor_inicialN;
Exemplo 2
public class MyClass {
    
    public static void main(String args[]) {
    
        final int a = 256;
        final int b = 1,c = 2, d =2;
    }
}
Saída

-

Uma vez declarada uma constante como no exemplo, qualquer atribuição de valor posterior a sua declaração irá gerar um erro de compilação:

Exemplo 3
public class MyClass {
    
    public static void main(String args[]) {
        final int a = 256;
        a =100;
    }
}
Saída
/MyClass.java:7: error: cannot assign a value to final variable a
a =100;
^
1 error

Para dar nomes a identificadores(variáveis, constantes, métodos e etc), podemos utilizar as convenções Pascal, Snake ou Camel case. Essas foram vistas em Portugol > Convenções.

Exemplo 4

nomeVariavel : Camel Case
NomeVariavel : Pascal Case
nome_variavel : Snake Case
NOME_CONSTANTE : Snake Case

A linguagem Java utiliza as convenções acima para nomear classes, variaveis, métodos, constantes e pacotes de forma predefinida.

Exemplo 6.1

NomeClasse: Camel Case
nomeVariavel : Pascal Case
nomeMetodo : Pascal Case
NOME_CONSTANTE : Snake Case

Além das convensões vistas acima, a linguagem Java utiliza as seguintes regras que são suportadas para dar nomes a identificadores, ou seja, variáveis, classes, métodos e etc:

  1. Deve conter as letras ( a-z, A-Z), $ ou underscore (_)
  2. O primeiro caractere pode utilizar $ ou _ seguido de caracteres definidos em item 1
  3. Constantes devem utilizar letras em caixa alta.
  4. Os nomes são case-sensitive. NOME e nome são visto como sendo diferentes
  5. Uma palavra reservada não pode ser utilizada, exceto como no item 2
Exemplo 5: Identificadores incorretos
int 1idade;
int idade pessoa; //espaço entre nomes
int int; // palavra reservada;
int #idade;
Exemplo 6: Identificadores corretos
int idade;
int idade_pessoa;
int idadePessoa
int IdadePessoa

Agora que já temos conhecimento sobre os tipos básicos de dados presentes na linguagem Java, vamos ver alguns exemplos de declaração de variáveis com os tipos de dados já vistos ou do usuário.

Exemplo 7
    float $float = 1.99f; //tambem aceita hex
    
    double vdouble = 1.99d; //tambem aceita hex
    
    int vint = 777; 
    int hexa = 0xff;
    int octal = 010; 
    int binario = 0b10101010; //aa
    
    String str = "uma string em java";
    String strNull = null;
    
    boolean flag = false;
    
    byte codigo = 10;
    
    char caracter = 'Z';
    char charhex = 0x41; //'A'
    
    int[] vetor = {0,1,2}; //vetor
    int[][] matriz = {{1,2},{3,4}};// matriz

Classes e enumeradores serão vistos em suas respectivas seções Enum e Classe. Outros tipos de dados serão vistos ao longo do tutorial.

A linguagem Java é case-sensitive. Quando declaramos identificadores homônimos em caixa alta e caixa baixa, esses são vistos como identificadores distintos.

No exemplo abaixo, declaramos duas variáveis com um mesmo nome: uma em caixa alta e outra em caixa baixa para demonstrar o uso do case-sensitive.

Exemplo 8
public class Main
{
	public static void main(String[] args) {
		
		int variavel = 10;
		int VARIAVEL = 10;
		
		System.out.println(variavel);
		System.out.println(VARIAVEL);
	}
}
Saída
10
10

Usando a palavra reservada var na declaração de variáveis, informamos que essas terão seus tipos de dados definidos durante a compilação usando inferência. O valor inicial atribuído à variável será usado como base para a escolha de seu tipo.

Sintaxe
var nome_varivel = <valor>;
Exemplo 9
public class Main
{
	public static void main(String[] args) {
		
        var inferencia1 = "string";
        var inferencia2 = 1.99f;
        
        System.out.println(inferencia1);
        System.out.println(inferencia2);
	}
}
Saída
string
1.99

A palavra var pode ser usada apenas quando a variável for iniciada. Uma vez que seu tipo tenha sido inferido, não será alterado por uma atribuição posterior.

Exemplo 10
public class Main
{
	public static void main(String[] args) {
		
        var inferencia = "string";

        System.out.println(inferencia);

        inferencia = 100;
	}
}
Saída
Main.java:17: error: incompatible types: int cannot be converted to String
        inferencia = 100;
                     ^
1 error

Java fornece o tipo de dado Optional que tem como objetivo dar a possibilidade de, por exemplo, um tipo de dado primitivo aceitar um valor opcional Empty. O uso do tipo Optional requer a importação de seu pacote.

Sintaxe
Optional<tipo> var_opcional = Optional.of(nome_variavel);

Optional<tipo> var_opcional = Optional.empty();
Onde
<tipo>: Integer, Float, Double, Character, String e outros
Exemplo 11
import java.util.Optional;

public class Main
{
	public static void main(String[] args) {
		
        int valor = 10;
        
        Optional<Integer> optValor = Optional.of(valor);
        
        System.out.println(optValor);
        
	}
}
Saída
Optional[10]

Os métodos isPresent e isEmpty devem ser utilizados para verificar se há valor ou não em uma variável Optional. Ambos métodos retornam um valor booleano.

Sintaxe
nome_var.isPresent();

nome_var.isEmpty();
Exemplo 12
import java.util.Optional;

public class Main
{
	public static void main(String[] args) {
		
        int valor = 10;
        Optional<Integer> optValor = Optional.of(valor);
        System.out.println(optValor.isPresent());
        System.out.println(optValor.isEmpty());
	}
}
Saída
true
false

O valor contido em um Optional é recuperado invocando o método get como pode ser visto no exemplo abaixo:

Sintaxe
nome_var.get();
Exemplo 13
import java.util.Optional;

public class Main
{
	public static void main(String[] args) {
		
        int valor = 10;
        Optional<Integer> optValor = Optional.of(valor);
        System.out.println(optValor.get());
        
	}
}
Saída
10

Para a crição de variáveis e constantes na linguagem Java, precisamos entender como funcionam os escopos local e classe.

O assunto escopo será melhor entendido após o estudo sobre O.O visto em Java: P.O.O, pois envolve métodos, atributos, modificadores de acesso entre outros.

Para a linguagem Java, por ser uma linguagem O.O, as variáveis criadas dentro de um método são consideradas locais. Essas variáveis são criada durante a execução do método e destruídas ao término da execução, quando não retornadas.

Exemplo 14
public class MyClass {
    
    public static void main(String args[]) {
    
        int a = 256; //escopo local
        final b = 1 //escopo local
    }
}
Saída
-

No exemplo cima, as váriváeis valor1 e valor2 são variáveis locais e só podem ser acessadas no escopo onde foram criadas.

Variáveis e constantes declaradas fora dos métodos, tem o escopo de classe sendo declaradas como no exemplo abaixo. Nesse escopo, as variáveis e constantes podem ser acessados por qualquer método da própria classe ou classe derivada dependendo o modificador de acesso.

Exemplo 15
public class MinhaClasse{
    public int a = 100;
    public final int b = 777;
    
    public void metodo(){
        //omitido
    }
}
Saída
-

[Java 21+] O discard de variáveis em Java é feito utilizando o identificador (_) também encontrado em algumas outras linguagens como Go, C# e Rust, por exemplo.

Com esse identificador podemos informar explicitamente parâmetros de expressões lambda, exceptions no bloco catch, destructuring(desmontar) do tipo record e outras situações semelhantes que não precisamos utilizar um valor recuperado.

No próximo exemplo, vamos ignorar o objeto exception lançado em um bloco try. No bloco catch, utilizamos o identificador (_) no lugar do argumento:

Exemplo 16
//Main.java
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

public class Main
{
	public static void main(String[] args) {

		try 
		{
			String arq = "arquivo nao existe";
			Files.readString(Path.of(arq)); //erro gerado
			
		} 
		catch (IOException _) //exception ignorada
		{
			System.out.println("Erro");
		}
	}
}
Saída
Erro

No exemplo abaixo, vamos desmontar os campos de uma tipo de dado record e ignorar um dos campos:

Exemplo 17
//Main.java
public class Main
{
	public record MeuRecord(int campo1, String campo2, float campo3) {}

	public static void main(String[] args) {

		MeuRecord obj = new MeuRecord(1, "teste", 9.12f);

		if (obj instanceof MeuRecord(int a, String b, float _)) //y ignorado
		{
			System.out.println("a: " + a); 
			System.out.println("b: " + b);
		}
	}
}
Saída
a:1
b:teste

No comando switch pattern ou match, podemos podemos também ignorar valores de forma semelhante ao que foi mostrado no exemplo acima:

Exemplo 18
//Main.java
public class Main
{
	public record MeuRecord(int campo1, String campo2, float campo3) {}

	public static void main(String[] args) {

		MeuRecord obj = new MeuRecord(2, "teste2", 9.12f);

		switch (obj)
		{
		    //ignorando campo1 e campo3
		    case MeuRecord(int _, String campo2, float _) ->
				System.out.println("campo2:" + campo2);
			default -> System.out.println("erro");
		}
	}
}
Saída
campo2:teste2

Assim como várias linguagens, Java possui suas palavras reservadas que são reconhecidas internamente como comandos e não podem ser utilizadas na declaração de identificadores como mencionando.

byte case catch char
do double else enum
extends final finally float
for goto if implements
import instanceof int interface
long native new package
private protected public return
short static strictfp this
throws transient try void
volatile while - -
  1. 12/08/2026 - revisão 7 - Adição: 'Descarte'
  2. 20/07/2026 - revisão 6 - Ajustes: navegação topo em case-sensitive, inferência e optional e outros pontuais
  3. 28/11/2025 - revisão 5 - Adição: case-sensitive, inferência e Optional. Ajustes: Objetivos e linguagem em exemplos
  4. 22/07/2025 - revisão 4 - Correção: Ordem escopo/exemplos de variáveis; Ajuste em estilo de sintaxes; melhorias pontuais
  5. 23/09/2024 - revisão 3 - Correção em sintaxe 'Constantes', link POO em 'escopo'; ajustes gramaticais e outros
  6. 02/09/2024 - revisão 2 - Correção em link de objetivo: Dar nomes as variáves e constantes
  7. 06/02/2024 - revisão 1 - correção em navegação e erros gramaticais
  8. 04/09/2023 - versão inicial