Zmienne w Javie: deklaracja, przypisanie i zasięg

Czym jest zmienna

Zmienna to nazwane pudełko, które przechowuje wartość. W Javie każda zmienna ma stały typ, ustalany przy deklaracji, i ten typ nigdy się nie zmienia. To właśnie sprawia, że Java jest językiem statycznie typowanym: kompilator zna typ każdej zmiennej, zanim program się uruchomi, i odmówi skompilowania kodu, który wkłada do pudełka wartość niewłaściwego rodzaju.

Deklaracja składa się z trzech części: typu, nazwy i (zwykle) wartości początkowej.

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

Czytaj int age = 30; jako "utwórz int o nazwie age i włóż do niego 30". Średnik kończy instrukcję, tak jak każdą instrukcję, co pokazała strona o komentarzach.

Najpierw deklaracja, przypisanie później

Deklarację można oddzielić od pierwszego przypisania. Typ podajesz raz, przy deklaracji; potem przypisujesz już tylko przez nazwę i =:

public class Main {
    public static void main(String[] args) {
        int score;        // zadeklarowana, jeszcze bez wartości
        score = 95;       // przypisana teraz
        score = 100;      // przypisana ponownie, to całkowicie poprawne

        System.out.println(score);
    }
}

Jedna reguła, na której potykają się początkujący: zmiennej lokalnej trzeba przypisać wartość, zanim się ją odczyta. Kompilator to śledzi i odrzuca kod, który odczytuje niezainicjalizowaną zmienną lokalną:

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

To zaleta, a nie utrudnienie: wyłapuje całą klasę błędów, zanim program w ogóle się uruchomi.

Zasady i konwencje nazewnictwa

Java narzuca kilka twardych reguł, a na nie nakłada konwencje. Reguły: nazwa może zawierać litery, cyfry, _ i $, ale nie może zaczynać się od cyfry, nie może być słowem zarezerwowanym (takim jak int czy class) i rozróżnia wielkość liter (age i Age to dwie różne zmienne).

Konwencje, których wszyscy się trzymają:

• Zmienne i metody zapisuje się w camelCase: firstName, totalScore.
• Stałe zapisuje się w UPPER_SNAKE_CASE: MAX_USERS.
• Nazwy powinny opisywać wartość: count, a nie c; userEmail, a nie x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

Czytelne nazwy to nie ozdoba: to dzięki nim za kilka miesięcy nadal zrozumiesz ten kod. totalPrice = itemCount * pricePerItem tłumaczy się samo, czego t = c * p nigdy nie osiągnie.

Bezpieczeństwo typów: pudełko zachowuje swój typ

Ponieważ typ jest ustalany przy deklaracji, nie włożysz do zmiennej wartości niewłaściwego typu. Takie pomyłki są wyłapywane w czasie kompilacji:

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

Przypisywanie między typami liczbowymi podlega regułom poszerzania (widening): mniejszy typ automatycznie przechodzi w większy, ale nie odwrotnie. Dokładnie omówimy to na stronach o typach danych i rzutowaniu typów; na razie wystarczy wiedzieć, że kompilator pilnuje.

Słowo kluczowe var

Od Javy 10 możesz napisać var zamiast typu i pozwolić kompilatorowi wywnioskować go z wartości po prawej stronie:

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // wywnioskowany jako String
        var count = 5;                 // wywnioskowany jako int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var to nie typowanie dynamiczne: name jest tak samo String, jak gdyby napisać String name, i nadal nie przypiszesz do niej później int. To tylko oszczędność pisania. Haczyk: var potrzebuje inicjalizatora, z którego wywnioskuje typ, więc var x; jest niedozwolone, a działa wyłącznie dla zmiennych lokalnych, nigdy dla pól, parametrów metod ani typów zwracanych. Używaj go tam, gdzie typ jest oczywisty z prawej strony; wypisz typ wprost, gdy to poprawia czytelność.

Stałe z final

Gdy wartość nie powinna się zmienić po ustawieniu, oznacz ją jako final. Każda próba ponownego przypisania staje się błędem kompilacji:

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // nie skompiluje się: zmiennej final nie można przypisać ponownie
    }
}

final komunikuje zamiar ("to stała wartość") i pozwala kompilatorowi jej pilnować. Sięgaj po nie zawsze, gdy wartość jest z natury stałą, np. stawki, limity czy klucze konfiguracji, żeby przypadkowe ponowne przypisanie zostało wyłapane, a nie po cichu trafiło do produkcji jako błąd.

Zasięg zmiennych

Zmienna istnieje tylko wewnątrz bloku, czyli { ... }, w którym została zadeklarowana, i znika przy nawiasie zamykającym. To jej zasięg (scope). Zmienna zadeklarowana wewnątrz pętli for albo bloku if jest poza nim niewidoczna:

public class Main {
    public static void main(String[] args) {
        int total = 0;

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' żyje tylko w ciele tej pętli
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // błąd: 'square' jest tu poza zasięgiem
    }
}

Zarówno i, jak i square należą do pętli i znikają, gdy się kończy; total jest zadeklarowana w bloku zewnętrznym, więc przetrwa. Wniosek praktyczny: deklaruj każdą zmienną w najmniejszym bloku, który jej potrzebuje. Wąski zasięg to mniej nazw walczących o twoją uwagę i mniej okazji, by źle użyć wartości daleko od miejsca, w którym ją ustawiono.

Dalej: typy danych

Każda zmienna na tej stronie zaczynała się od typu: int, double, String, boolean. Następna strona szczegółowo omawia typy danych w Javie: osiem typów prostych, rozmiar każdego z nich, różnicę między typami prostymi a obiektami i to, po który typ sięgnąć w danej sytuacji.