Java Academy · Lektion

Omfattning och livslängd

Förstå var variabler är synliga (omfattning) och hur länge de finns (livslängd): block, loopar, metoder, fält, skuggning och final-parametrar.

Lektion 3 av 38 steg

Omfattning och livslängd är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 3 av 3. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 3 lektioner.

Räckvidd kontra livslängd

Räckvidd = var ett namn (en variabel) är synligt. Livslängd = hur länge variabeln existerar. Ni får se blockets räckvidd, loopens räckvidd, lokala metodvariabler, klassfält och regler för skuggning.

Blockets räckvidd

Blockets räckvidd: en variabel som deklareras inom klamrarna är bara synlig inom dessa klamrar.

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

Loopens räckvidd

Loopens räckvidd: ett loopindex som deklareras i for-huvudet är bara synligt i loopens kropp.

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

Fält kontra lokala variabler

Livslängd: klass- och statiska fält lever kvar mellan anrop; lokala variabler skapas på nytt vid varje anrop och tas sedan bort när metoden avslutas.

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

Skuggning

Skuggning: en inre deklaration, till exempel en parameter eller lokal variabel, kan dölja ett yttre namn med samma identifierare. Använd ClassName.field (eller this.field i instansmetoder) för att komma åt det dolda fältet.

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 och pass-by-value

final-parametrar kan inte tilldelas om. Java använder pass-by-value: att tilldela parametern ett nytt värde ändrar inte anroparens variabel.

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

Kontroll av räckvidd/livslängd

Snabb kontroll: Vilket påstående om räckvidd och livslängd är SANT?

Repetition och nästa steg

Repetition: Ni övade på blockets och loopens räckvidd, fält kontra lokala variabler, skuggning och final-parametrar. Nästa steg: gå vidare till design- och återanvändningsmönster i A2.2.

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
104
Lektioner
374

Vanliga frågor

Är lektionen ”Omfattning och livslängd” gratis?

Ja – hela texten till ”Omfattning och livslängd” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 3 lektioner.

Vad lär jag mig i ”Omfattning och livslängd”?

Förstå var variabler är synliga (omfattning) och hur länge de finns (livslängd): block, loopar, metoder, fält, skuggning och final-parametrar. Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 3.

Hur lång tid tar lektionen ”Omfattning och livslängd”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Definiera metoder och parametrar
  2. Returvärden och överlagring
  3. Omfattning och livslängd
← Tillbaka till Java Academy