Typy danych w Javie: typy proste, referencyjne i wartości domyślne

Dwie rodziny: typy proste i referencje

Każda wartość w Javie ma typ, a ten typ należy do jednej z dwóch rodzin. Typy proste (prymitywne) przechowują surową wartość bezpośrednio: liczbę, pojedynczy znak albo prawdę/fałsz. Typy referencyjne przechowują referencję (wskaźnik) do obiektu, który znajduje się gdzie indziej w pamięci: String, tablice i każda klasa zdefiniowana przez ciebie lub biblioteki.

To rozróżnienie ma znaczenie, bo typy proste są lekkie i kopiowane przez wartość, a zmienne referencyjne wskazują na współdzielone obiekty. Zacznij od ośmiu typów prostych: to fundament, na którym zbudowane jest wszystko inne.

Osiem typów prostych

Java ma dokładnie osiem wbudowanych typów prostych. Sześć to liczby, jeden to znak i jeden to wartość logiczna:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // liczba całkowita 8-bitowa,  -128 .. 127
        short  s = 30000;        // liczba całkowita 16-bitowa
        int    i = 2_000_000;    // liczba całkowita 32-bitowa (domyślna dla liczb całkowitych)
        long   big = 9_000_000_000L; // liczba całkowita 64-bitowa, zwróć uwagę na L

        float  f = 3.14f;        // liczba dziesiętna 32-bitowa, zwróć uwagę na f
        double d = 3.141592653589793; // liczba dziesiętna 64-bitowa (domyślna dla ułamków)

        char   c = 'A';          // pojedynczy 16-bitowy znak Unicode
        boolean flag = true;     // tylko true albo false

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

Kilka rzeczy wartych uwagi od razu: podkreślenia w 2_000_000 to tylko wizualne separatory, które kompilator ignoruje, sufiksy L i f są wymagane (więcej o tym niżej), a char używa pojedynczych cudzysłowów, podczas gdy String używałby podwójnych.

Wybór typu liczbowego

Prawie nigdy nie potrzebujesz byte ani short: oszczędzają pamięć tylko w ogromnych tablicach. Prawdziwe decyzje to wybór między int/long dla liczb całkowitych i float/double dla liczb dziesiętnych.

Pułapką jest przepełnienie. int po przekroczeniu zakresu po cichu „przekręca się”: bez błędu, po prostu z błędnym wynikiem:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // przekręca się na liczbę ujemną!

        long safe = (long) maxInt + 1;  // najpierw rozszerzamy do long
        System.out.println(safe);
    }
}

maxInt + 1 przepełnia się do -2147483648, bo oba operandy są typu int i wynik też pozostaje int. Rzutowanie jednej strony na long sprawia, że obliczenie odbywa się na 64 bitach. Gdy wartość może być duża, zwłaszcza liczba milisekund od 1970 roku, sięgaj po long.

Literały i ich sufiksy

Sam literał liczbowy ma typ domyślny i to często zaskakuje. 100 to int, a 3.14 to double. Aby zapisać literał long lub float, musisz dodać sufiks:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // bez L to za dużo dla int -> błąd
        float ratio = 0.5f;               // bez f prawa strona to double -> błąd
        double pi = 3.14;                 // w porządku: ułamki domyślnie są double

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

Usuń L z 8_000_000_000L, a kod się nie skompiluje, bo literał przekracza zakres int, zanim w ogóle trafi do zmiennej long. Usuń f z 0.5f, a Java zgłosi, że double nie można przypisać do float bez rzutowania. Wielkość liter sufiksu nie ma znaczenia, ale używaj wielkiego L: małe l wygląda dokładnie jak cyfra 1.

char to przebrana liczba

char przechowuje 16-bitową jednostkę kodu Unicode, co oznacza, że działa też jak mała liczba całkowita bez znaku. Możesz wykonywać na nim działania arytmetyczne i konwertować go w obie strony rzutowaniem:

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65, czyli wartość Unicode 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

Czasem przydaje się to do przesuwania liter, ale nie opieraj na tym pracy z tekstem: do tego służy String. Zauważ, że char używa pojedynczych cudzysłowów ('A'), a podwójne ("A") tworzą jednoznakowy String, który jest zupełnie innym typem.

Wartości domyślne (i pułapka zmiennych lokalnych)

Pola i elementy tablic, których nie zainicjalizujesz, dostają sensowną wartość domyślną. Dotyczy to jednak tylko pól i elementów tablic: zmienne lokalne nie mają wartości domyślnej, a użycie takiej zmiennej przed przypisaniem wartości to błąd kompilacji, a nie niespodzianka w czasie działania.

public class Main {
    static int counter;        // pole -> domyślnie 0
    static boolean ready;      // pole -> domyślnie false
    static String name;        // pole -> domyślnie null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // elementy tablicy domyślnie mają 0
        System.out.println(nums[0]); // 0
    }
}

Gdybyś zamiast tego napisał w main kod int x; System.out.println(x);, kompilator odrzuciłby go z komunikatem „variable x might not have been initialized”. Ta surowość to zaleta: nie pozwala odczytać śmieci. Wartości domyślne do zapamiętania: typy liczbowe 0, boolean false, char '�' i każdy typ referencyjny null.

Dalej: napisy

String to typ referencyjny, z którego będziesz korzystać najczęściej: tekst, łączone wartości, dane od użytkownika. Zachowuje się inaczej niż omówione tu typy proste: jest obiektem, jest niezmienny, a porównywanie napisów ma własne pułapki. Omawia go następna strona.