Java Academy · Lekcja

Zakres i czas życia

Poznają Państwo, gdzie zmienne są widoczne (zakres) i jak długo istnieją (czas życia): w blokach, pętlach, metodach i polach, a także zasłanianie nazw i parametry final.

Zakres i czas życia to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 z 3. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 3 lekcji w sumie.

Zakres a czas życia

Zakres oznacza miejsce, w którym nazwa, na przykład zmienna, jest widoczna. Czas życia oznacza, jak długo istnieje zmienna. Poznane zostaną zakres bloku, zakres pętli, zmienne lokalne metod, pola klas i zasady przesłaniania.

Zakres bloku

Zakres bloku: zmienna zadeklarowana wewnątrz nawiasów klamrowych jest widoczna tylko w ich obrębie.

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

Zakres pętli

Zakres pętli: indeks pętli zadeklarowany w nagłówku for jest widoczny tylko wewnątrz treści pętli.

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

Pola a zmienne lokalne

Czas życia: pola klas i pól statycznych istnieją między kolejnymi wywołaniami, natomiast zmienne lokalne są tworzone przy każdym wywołaniu i usuwane po zakończeniu metody.

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

Przesłanianie

Przesłanianie: deklaracja wewnętrzna, na przykład parametr lub zmienna lokalna, może ukryć zewnętrzną nazwę o tym samym identyfikatorze. Aby uzyskać dostęp do ukrytego pola, należy użyć ClassName.field lub this.field w metodach instancji.

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 i przekazywanie przez wartość

Parametr oznaczony jako final nie może zostać ponownie przypisany. Java stosuje przekazywanie przez wartość: ponowne przypisanie parametru nie zmienia zmiennej wywołującego.

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

Sprawdzenie zakresu i czasu życia

Szybkie sprawdzenie: Które stwierdzenie dotyczące zakresu i czasu życia jest PRAWDZIWE?

Podsumowanie i następny krok

Podsumowanie: Ćwiczono zakres bloku i pętli, pola i zmienne lokalne, przesłanianie oraz parametry final. Następnie omówione zostaną wzorce projektowe i ponowne wykorzystanie kodu w A2.2.

Często zadawane pytania

Czy lekcja „Zakres i czas życia” jest bezpłatna?

Tak — pełny tekst „Zakres i czas życia” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 3 lekcji w sumie.

Co nauczysz się w „Zakres i czas życia”?

Poznają Państwo, gdzie zmienne są widoczne (zakres) i jak długo istnieją (czas życia): w blokach, pętlach, metodach i polach, a także zasłanianie nazw i parametry final. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 3.

Ile czasu zajmuje lekcja „Zakres i czas życia”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Java Academy