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.
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.
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
- Definiera metoder och parametrar
- Returvärden och överlagring
- Omfattning och livslängd