Java Academy · Aula

Escopo e tempo de vida

Compreenda onde as variáveis são visíveis (escopo) e por quanto tempo existem (tempo de vida): blocos, ciclos, métodos, campos, ocultação e parâmetros final.

Escopo e tempo de vida é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 3 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 3 aulas no total.

Escopo vs tempo de vida

Escopo = onde um nome (variável) é visível. Tempo de vida = por quanto tempo a variável existe. Você verá escopo de bloco, escopo de laço, variáveis locais de métodos, campos de classe e regras de ocultação.

Escopo de bloco

Escopo de bloco: uma variável declarada dentro de chaves só fica visível dentro dessas chaves.

public class Main {
  public static void main(String[] args) {
    int a = 10; // visible in main
    {
      int b = 20; // visible only inside this block
      System.out.println("inside block: a=" + a + ", b=" + b);
    }
    System.out.println("outside block: a=" + a);
    // System.out.println(b); // would NOT compile: b is out of scope
  }
}

Escopo de laço

Escopo de laço: um índice de laço declarado no cabeçalho de for só fica visível dentro do corpo do laço.

public class Main {
  public static void main(String[] args) {
    for (int i = 0; i < 3; i = i + 1) {
      System.out.println("i in loop = " + i);
    }
    // System.out.println(i); // would NOT compile: i is scoped to the loop

    int j;
    for (j = 0; j < 2; j = j + 1) {
      System.out.println("j in loop = " + j);
    }
    System.out.println("j after loop = " + j); // OK: j declared outside
  }
}

Campos vs variáveis locais

Tempo de vida: campos de classe ou estáticos permanecem entre chamadas; variáveis locais são recriadas a cada chamada e depois descartadas quando o método termina.

public class Main {
  // static field (class-level): lives for the program lifetime
  static int counter = 0;

  static void tick() {
    int local = 100; // local: created each call, dies when method returns
    counter = counter + 1;
    System.out.println("tick: counter=" + counter + ", local=" + local);
  }

  public static void main(String[] args) {
    tick();
    tick();
    tick();
    System.out.println("final counter=" + counter);
  }
}

Ocultação

Ocultação: uma declaração interna (por exemplo, um parâmetro ou uma variável local) pode ocultar um nome externo com o mesmo identificador. Use ClassName.field (ou this.field em métodos de instância) para acessar o campo oculto.

public class Main {
  static String label = "FIELD"; // class field

  static void demo(String label) { // parameter shadows field name
    System.out.println("param label = " + label); // uses parameter
    {
      String labelInner = "INNER"; // new name in inner block
      System.out.println("inner block labelInner = " + labelInner);
      System.out.println("still param label = " + label);
    }
    System.out.println("field via class name = " + Main.label); // refer to field explicitly
  }

  public static void main(String[] args) {
    demo("PARAM");
  }
}

Final e passagem por valor

Parâmetros final não podem ser reatribuídos. Java usa passagem por valor: reatribuir o parâmetro não altera a variável de quem chama.

public class Main {
  // final parameter cannot be reassigned inside the method
  static int inc(final int n) {
    // n = n + 1; // would NOT compile if uncommented
    return n + 1; // safe: return a new value
  }

  static void reassign(int x) {
    x = 999; // reassignes the local copy; caller variable is unchanged
  }

  public static void main(String[] args) {
    int a = 5;
    int b = inc(a);
    System.out.println("a=" + a + ", b=inc(a)=" + b);

    reassign(a);
    System.out.println("after reassign(a): a is still " + a);
  }
}

Verificação de escopo e tempo de vida

Verificação rápida: Qual afirmação sobre escopo e tempo de vida é TRUE?

Recapitulação e próxima etapa

Recapitulação: Você praticou escopo de bloco e de laço, campos e variáveis locais, ocultação e parâmetros final. A seguir: avance para padrões de projeto e reutilização em A2.2.

Perguntas Frequentes

A aula “Escopo e tempo de vida” é grátis?

Sim — o texto completo de “Escopo e tempo de vida” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 3 aulas no total.

O que vou aprender em “Escopo e tempo de vida”?

Compreenda onde as variáveis são visíveis (escopo) e por quanto tempo existem (tempo de vida): blocos, ciclos, métodos, campos, ocultação e parâmetros final. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 3.

Quanto tempo leva a aula “Escopo e tempo de vida”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy