Guia completo para entender declaração, ciclo de vida e escopo de variáveis em Java
Variáveis são como caixas que armazenam informações na memória do computador. Cada variável tem um nome (identificador), um tipo que define que tipo de dado ela pode guardar, e um valor.
Pense em variáveis como gavetas etiquetadas: a etiqueta é o nome da variável, o tipo da gaveta determina o que pode ser guardado nela (números, textos, etc.), e o conteúdo dentro é o valor atual.
Entender variáveis e seu escopo é fundamental para escrever código organizado, eficiente e sem erros. O escopo determina onde uma variável existe e pode ser acessada no seu programa.
Declarar uma variável significa criar um espaço na memória para ela. Você precisa informar o tipo e o nome da variável.
tipo nomeVariavel;Inicializar é dar um valor inicial à variável. Você pode declarar e inicializar ao mesmo tempo ou separadamente.
// Declaração e inicialização separadas
int idade;
idade = 25;
// Declaração e inicialização juntas (recomendado)
int idade = 25;
String nome = "Maria";
double salario = 3500.50;
boolean ativo = true;São declaradas dentro de métodos, construtores ou blocos. Elas só existem dentro do bloco onde foram criadas.
public class Exemplo {
public void calcular() {
int numero = 10; // Variável local
double resultado = numero * 2.5;
System.out.println(resultado);
} // 'numero' e 'resultado' deixam de existir aqui
}São declaradas dentro da classe, mas fora dos métodos. Cada objeto da classe tem sua própria cópia dessas variáveis.
public class Pessoa {
// Variáveis de instância
String nome;
int idade;
public void apresentar() {
System.out.println("Meu nome é " + nome);
System.out.println("Tenho " + idade + " anos");
}
}São declaradas com a palavra-chave static. São compartilhadas por todos os objetos da classe.
public class Contador {
static int totalObjetos = 0; // Variável de classe
public Contador() {
totalObjetos++; // Incrementa para cada objeto criado
}
public static void mostrarTotal() {
System.out.println("Total de objetos: " + totalObjetos);
}
}| Tipo | Onde Declarar | Tempo de Vida | Acesso |
|---|---|---|---|
| Local | Dentro de métodos/blocos | Durante execução do método | Apenas no bloco onde foi criada |
| Instância | Dentro da classe, fora dos métodos | Enquanto o objeto existir | Por todos os métodos da instância |
| Classe (static) | Dentro da classe com static | Durante toda execução do programa | Por todas as instâncias e pela classe |
Escopo é a região do código onde uma variável é visível e pode ser acessada. Java tem escopo de bloco, ou seja, variáveis existem apenas dentro das chaves { } onde foram declaradas.
public class ExemploEscopo {
// Variável de classe (escopo: toda a classe)
static int contadorGlobal = 0;
// Variável de instância (escopo: todos os métodos do objeto)
String nome = "Java";
public void metodo1() {
// Variável local (escopo: apenas neste método)
int numero = 10;
System.out.println(nome); // OK - variável de instância
System.out.println(contadorGlobal); // OK - variável static
System.out.println(numero); // OK - variável local
if (numero > 5) {
// Variável de bloco (escopo: apenas dentro deste if)
int resultado = numero * 2;
System.out.println(resultado); // OK - está no mesmo bloco
}
// System.out.println(resultado); // ERRO! 'resultado' não existe aqui
}
public void metodo2() {
System.out.println(nome); // OK - variável de instância
System.out.println(contadorGlobal); // OK - variável static
// System.out.println(numero); // ERRO! 'numero' é do metodo1
}
}Exemplo 1: Variáveis Locais em Métodos
public class Calculadora {
public int somar(int a, int b) {
int resultado = a + b; // Variável local
return resultado;
}
public int multiplicar(int a, int b) {
int resultado = a * b; // Outra variável local (diferente da anterior)
return resultado;
}
}Exemplo 2: Variáveis de Instância
public class ContaBancaria {
// Variáveis de instância
String titular;
double saldo;
public ContaBancaria(String titular, double saldoInicial) {
this.titular = titular;
this.saldo = saldoInicial;
}
public void depositar(double valor) {
saldo += valor; // Acessa variável de instância
System.out.println("Novo saldo: " + saldo);
}
public void sacar(double valor) {
if (valor <= saldo) {
saldo -= valor;
System.out.println("Saque realizado. Saldo: " + saldo);
} else {
System.out.println("Saldo insuficiente!");
}
}
}Exemplo 3: Variável Static Compartilhada
public class Aluno {
String nome;
static int totalAlunos = 0; // Compartilhada por todos os alunos
public Aluno(String nome) {
this.nome = nome;
totalAlunos++; // Incrementa o contador compartilhado
}
public static void mostrarTotal() {
System.out.println("Total de alunos: " + totalAlunos);
}
}
// Uso:
// Aluno a1 = new Aluno("João");
// Aluno a2 = new Aluno("Maria");
// Aluno.mostrarTotal(); // Saída: Total de alunos: 2Exemplo 4: Escopo em Loops
public class ExemploLoop {
public void processar() {
int soma = 0; // Variável do método
for (int i = 0; i < 5; i++) {
// 'i' só existe dentro do for
int quadrado = i * i; // Variável do bloco for
soma += quadrado;
System.out.println("i: " + i + ", quadrado: " + quadrado);
}
System.out.println("Soma total: " + soma);
// System.out.println(i); // ERRO! 'i' não existe aqui
// System.out.println(quadrado); // ERRO! 'quadrado' não existe aqui
}
}public void exemplo() {
int numero; // Declarada mas não inicializada
System.out.println(numero); // ERRO! Variável não inicializada
// Correção:
int numero2 = 0; // Sempre inicialize
System.out.println(numero2); // OK
}public void exemplo() {
if (true) {
int x = 10;
}
System.out.println(x); // ERRO! 'x' não existe aqui
// Correção: Declare fora do bloco
int y;
if (true) {
y = 10;
}
System.out.println(y); // OK
}Crie um programa que declare variáveis para armazenar nome, idade e altura de uma pessoa, inicialize-as e imprima os valores.
public class DadosPessoa {
public static void main(String[] args) {
String nome = "Carlos";
int idade = 28;
double altura = 1.75;
System.out.println("Nome: " + nome);
System.out.println("Idade: " + idade + " anos");
System.out.println("Altura: " + altura + " m");
}
}Identifique e corrija o erro no código abaixo relacionado ao escopo de variáveis.
public void calcular() {
if (true) {
int resultado = 100;
}
System.out.println(resultado); // Erro aqui
}Problema: A variável resultado foi declarada dentro do bloco if, então não existe fora dele.
public void calcular() {
int resultado; // Declarar fora do bloco
if (true) {
resultado = 100; // Atribuir dentro do bloco
}
System.out.println(resultado); // Agora funciona
}Crie uma classe Produto com um contador static que incremente cada vez que um produto é criado. Adicione também atributos de instância para nome e preço.
public class Produto {
// Variável de classe (compartilhada)
static int totalProdutos = 0;
// Variáveis de instância (única por objeto)
String nome;
double preco;
public Produto(String nome, double preco) {
this.nome = nome;
this.preco = preco;
totalProdutos++; // Incrementa contador global
}
public void exibir() {
System.out.println("Produto: " + nome);
System.out.println("Preço: R$ " + preco);
}
public static void mostrarTotal() {
System.out.println("Total de produtos: " + totalProdutos);
}
}
// Teste:
// Produto p1 = new Produto("Notebook", 2500.00);
// Produto p2 = new Produto("Mouse", 50.00);
// Produto.mostrarTotal(); // Saída: Total de produtos: 2Crie um método que some os números de 1 a 10 usando um loop for. A variável de controle do loop deve ter escopo apenas dentro do loop.
public class SomaNumeros {
public static void main(String[] args) {
int soma = 0; // Variável do método
for (int i = 1; i <= 10; i++) {
// 'i' tem escopo apenas no loop
soma += i;
}
System.out.println("Soma: " + soma);
// System.out.println(i); // Erro: 'i' não existe aqui
}
}Declare uma constante para o valor do PI e use-a para calcular a área de um círculo dado o raio.
public class CalculoCirculo {
// Constante (não pode ser alterada)
static final double PI = 3.14159;
public static double calcularArea(double raio) {
return PI * raio * raio;
}
public static void main(String[] args) {
double raio = 5.0;
double area = calcularArea(raio);
System.out.println("Área do círculo: " + area);
}
}Local: Dentro de métodos/blocos - existe apenas durante execução
Instância: Atributos da classe - cada objeto tem sua cópia
Classe (static): Compartilhada por todos - existe durante todo programa
• Variável só existe dentro das chaves { } onde foi declarada
• Variáveis locais não são inicializadas automaticamente
• Variáveis de instância são inicializadas com valores padrão
• Use this para diferenciar variável de instância de parâmetro
• Declare variáveis no menor escopo possível
• Variáveis locais para cálculos temporários em métodos
• Variáveis de instância para características de objetos (nome, idade, saldo)
• Variáveis static para contadores, configurações globais
• Constantes (final) para valores fixos (PI, taxa de conversão, etc.)
Entender variáveis e escopo é fundamental para escrever código Java organizado e eficiente. Saber onde declarar cada tipo de variável e compreender seu ciclo de vida evita erros e melhora a qualidade do seu código.
Continue praticando e logo você estará usando variáveis e gerenciando escopos naturalmente em seus projetos!