Java Academy · Lezione

Ambito e ciclo di vita

Comprendere dove le variabili sono visibili (ambito) e quanto a lungo esistono (ciclo di vita): blocchi, cicli, metodi, campi, shadowing e parametri final.

Ambito e ciclo di vita è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 3 di 3. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 3 lezioni in totale.

Ambito e durata di vita

Ambito = dove un nome, cioè una variabile, è visibile. Durata di vita = per quanto tempo esiste la variabile. Vedrà l'ambito dei blocchi, dei cicli e delle variabili locali dei metodi, i campi della classe e le regole dell'ombreggiamento.

Ambito dei blocchi

Ambito dei blocchi: una variabile dichiarata tra parentesi graffe è visibile solo all'interno di quelle parentesi.

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
  }
}

Ambito dei cicli

Ambito dei cicli: un indice del ciclo dichiarato nell'intestazione di for è visibile solo all'interno del corpo del ciclo.

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
  }
}

Campi e variabili locali

Durata di vita: i campi statici e di classe vivono tra una chiamata e l'altra; le variabili locali vengono ricreate a ogni chiamata e poi eliminate al termine del metodo.

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);
  }
}

Ombreggiamento

Ombreggiamento: una dichiarazione interna, ad esempio un parametro o una variabile locale, può nascondere un nome esterno con lo stesso identificatore. Utilizzi ClassName.field, oppure this.field nei metodi di istanza, per accedere al campo nascosto.

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 passaggio per valore

I parametri final non possono essere riassegnati. Java utilizza il passaggio per valore: riassegnare il parametro non modifica la variabile del chiamante.

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 di ambito e durata di vita

Verifica rapida: quale affermazione su ambito e durata di vita è VERA?

Riepilogo e prossimo passo

Riepilogo: Ha fatto pratica con l'ambito dei blocchi e dei cicli, i campi rispetto alle variabili locali, l'ombreggiamento e i parametri final. Prossimo passo: passare ai modelli di progettazione e riutilizzo in A2.2.

Domande Frequenti

La lezione «Ambito e ciclo di vita» è gratuita?

Sì — il testo completo di «Ambito e ciclo di vita» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 3 lezioni in totale.

Cosa imparerò in «Ambito e ciclo di vita»?

Comprendere dove le variabili sono visibili (ambito) e quanto a lungo esistono (ciclo di vita): blocchi, cicli, metodi, campi, shadowing e parametri final. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 3.

Quanto tempo richiede la lezione «Ambito e ciclo di vita»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy