Rzutowanie typów w Javie: rozszerzanie, zawężanie i konwersje

Co oznacza rzutowanie typów

Java ma typowanie statyczne: każda wartość ma typ, a kompilator nie pozwoli po cichu mieszać niezgodnych typów. Rzutowanie typów to sposób na zamianę wartości z jednego typu na inny. Czasem Java robi to za ciebie, a czasem trzeba o to poprosić wprost.

Są dwa kierunki. Przejście z mniejszego typu do większego (int do double) jest bezpieczne i dzieje się automatycznie. Przejście z większego do mniejszego (double do int) może stracić dane, więc Java wymaga, żeby zapisać je jawnie za pomocą rzutowania.

Rozszerzanie: konwersja automatyczna

Konwersja rozszerzająca przenosi wartość do typu, w którym jest więcej miejsca. Nic nie może zginąć, więc Java robi to za ciebie bez rzutowania:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, automatycznie

        System.out.println(price);   // 7.0
    }
}

int 7 trafia do double i staje się 7.0. Kolejność rozszerzania dla liczb to byte -> short -> int -> long -> float -> double; przypisanie od lewej do prawej wzdłuż tego łańcucha nigdy nie wymaga rzutowania. Dlatego mieszanie typów w arytmetyce często "po prostu działa": Java najpierw rozszerza mniejszy operand.

Zawężanie: jawne rzutowanie

W drugą stronę, przy konwersji zawężającej, dane mogą przepaść, więc kompilator odmawia, dopóki nie wpiszesz typu docelowego w nawiasie przed wartością:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // jawne rzutowanie zawężające

        System.out.println(whole);   // 3, a nie 4
    }
}

(int) pi to rzutowanie. Zwróć uwagę, co robi: obcina w stronę zera, po prostu odrzucając część dziesiętną. 3.9 staje się 3, a -3.9 staje się -3. Nie zaokrągla. Jeśli chcesz zaokrąglić, potrzebujesz innego narzędzia:

public class Main {
    public static void main(String[] args) {
        double value = 3.9;

        System.out.println((int) value);          // 3  (obcina)
        System.out.println(Math.round(value));    // 4  (zaokrągla)
    }
}

Zapominanie, że rzutowanie obcina, to jeden z najczęstszych błędów początkujących: jeśli twoja "zaokrąglona" liczba zawsze wychodzi o jeden za mała, zwykle właśnie to jest powodem.

Pułapka dzielenia całkowitego

Na tę pułapkę każdy prędzej czy później się nadziewa. Gdy oba operandy są typu int, operator / wykonuje dzielenie całkowite i wyrzuca resztę, i to zanim nastąpi jakiekolwiek przypisanie do double:

public class Main {
    public static void main(String[] args) {
        int a = 7;
        int b = 2;

        double wrong = a / b;          // 3.0, bo dzielenie odbywa się najpierw na intach!
        double right = (double) a / b; // 3.5, bo najpierw rzutujesz jeden operand

        System.out.println(wrong);
        System.out.println(right);
    }
}

a / b to 7 / 2, obliczone w całości w arytmetyce int, co daje 3. Późniejsze rozszerzenie do double zamienia tylko 3 na 3.0: .5 już przepadło. Rzutowanie jednego operandu na double na początku ((double) a / b) przenosi całe wyrażenie w świat liczb zmiennoprzecinkowych i daje oczekiwane 3.5. Wystarczy rzutować jedną stronę, a Java rozszerzy drugą, żeby pasowała.

Gdy zawężanie powoduje przepełnienie

Rzutowanie nie sprawdza, czy wartość się mieści. Jeśli się nie mieści, bity zostają po prostu ucięte i dostajesz zaskakujący wynik, bez błędu i bez ostrzeżenia:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte mieści tylko -128..127

        System.out.println(small);   // 44, a nie 300
    }
}

300 nie mieści się w byte, więc wyższe bity zostają odrzucone i dostajesz 44. To "cicha" utrata danych: program działa bez zarzutu i daje złą odpowiedź. Zawężaj tylko wtedy, gdy masz pewność, że wartość zmieści się w mniejszym typie.

Konwersja między liczbami a stringami

String to obiekt, a nie liczba, więc nie da się go zrzutować przez (int): to błąd kompilacji. Do konwersji służą osobne metody:

public class Main {
    public static void main(String[] args) {
        String text = "42";
        int n = Integer.parseInt(text);       // String -> int
        double d = Double.parseDouble("3.14"); // String -> double

        System.out.println(n + 1);   // 43

        String back = String.valueOf(n);       // int -> String
        System.out.println(back + "!");         // 42!
    }
}

Z tekstu na liczbę przechodzisz przez Integer.parseInt / Double.parseDouble. Jeśli napis nie jest poprawną liczbą (np. "hello"), te metody rzucają NumberFormatException. Z liczby na tekst użyj String.valueOf(n) albo po prostu dołącz "", bo n + "" zamienia int w String. Uważaj na różnicę między "5" + 1 (daje napis "51") a 5 + 1 (daje 6): + oznacza łączenie napisów, gdy tylko w grę wchodzi String.

Rzutowanie obiektów

Rzutowanie dotyczy też referencji do obiektów, nie tylko typów prostych. Referencję możesz zrzutować na spokrewniony typ w łańcuchu dziedziczenia: rozszerzenie do typu nadrzędnego jest automatyczne, a zawężenie z powrotem wymaga jawnego rzutowania i jest bezpieczne tylko wtedy, gdy obiekt naprawdę jest tego typu:

Object o = "hello";
String s = (String) o;        // OK: o naprawdę wskazuje na String
Integer bad = (Integer) o;    // kompiluje się, ale w czasie działania rzuca ClassCastException

Drugie rzutowanie się kompiluje, ale w czasie działania kończy się ClassCastException, bo obiekt jest typu String, a nie Integer. Poznasz to dokładnie, gdy dojdziesz do dziedziczenia i polimorfizmu; na razie wystarczy wiedzieć, że składnia (Type) to ten sam pomysł zastosowany do obiektów.