Приведение типов в Java: расширение, сужение и преобразования

Что такое приведение типов

Java — язык со статической типизацией: у каждого значения есть тип, и компилятор не позволит вам незаметно смешивать несовместимые типы. Приведение типов — это способ преобразовать значение из одного типа в другой: иногда Java делает это за вас, а иногда вы должны попросить об этом явно.

Есть два направления. Переход от меньшего типа к большему (из int в double) безопасен и происходит автоматически. Переход от большего типа к меньшему (из double в int) может привести к потере данных, поэтому Java заставляет вас указать это с помощью приведения.

Расширение: автоматическое преобразование

Расширяющее преобразование перемещает значение в тип с большим запасом. Ничего не может быть потеряно, поэтому Java делает это за вас без приведения:

public class Main {
    public static void main(String[] args) {
        int count = 7;
        double price = count;   // int -> double, автоматически

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

int 7 помещается в double и становится 7.0. Порядок расширения для чисел такой: byte -> short -> int -> long -> float -> double; присваивание слева направо по этой цепочке никогда не требует приведения. Именно поэтому смешивание типов в арифметике часто «просто работает» — Java сначала расширяет меньший операнд.

Сужение: явное приведение

В обратную сторону — сужающее преобразование — может терять данные, поэтому компилятор откажет, если вы не поставите целевой тип в скобках перед значением:

public class Main {
    public static void main(String[] args) {
        double pi = 3.9;
        int whole = (int) pi;   // явное сужающее приведение

        System.out.println(whole);   // 3, а не 4
    }
}

(int) pi — это приведение. Обратите внимание, что оно делает: оно отбрасывает дробную часть в сторону нуля, просто удаляя её. 3.9 становится 3, а -3.9 становится -3. Оно не округляет. Если вам нужно округление — это другой инструмент:

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

        System.out.println((int) value);          // 3  (отбрасывает дробную часть)
        System.out.println(Math.round(value));    // 4  (округляет)
    }
}

Забыть, что приведение отбрасывает дробную часть, — одна из самых частых ошибок новичков: если ваше «округлённое» число всегда на единицу меньше нужного, обычно причина именно в этом.

Ловушка целочисленного деления

В эту ловушку попадается каждый хотя бы раз. Когда оба операнда — int, оператор / выполняет целочисленное деление и отбрасывает остаток — до того, как произойдёт присваивание в double:

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

        double wrong = a / b;          // 3.0  - деление сначала выполнено как int!
        double right = (double) a / b; // 3.5  - сначала приведи один операнд

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

a / b — это 7 / 2, вычисленное полностью в целочисленной арифметике int, что даёт 3. Последующее расширение до double лишь превращает 3 в 3.0 — .5 уже потеряно. Если сначала привести один операнд к double ((double) a / b), всё выражение переходит в арифметику с плавающей точкой и даёт нужное 3.5. Достаточно привести только одну сторону; Java расширит другую, чтобы они совпали.

Когда сужение переполняется

Приведение не проверяет, помещается ли значение. Если оно не помещается, биты просто обрезаются, и вы получаете неожиданный результат — без ошибки, без предупреждения:

public class Main {
    public static void main(String[] args) {
        int big = 300;
        byte small = (byte) big;   // byte вмещает только -128..127

        System.out.println(small);   // 44, а не 300
    }
}

300 не помещается в byte, поэтому старшие биты отбрасываются, и вы получаете 44. Это «тихая» потеря данных — программа работает нормально и выдаёт неверный ответ. Сужайте только тогда, когда уверены, что значение помещается в меньший тип.

Преобразование между числами и строками

String — это объект, а не число, поэтому привести его через (int) нельзя — это ошибка компиляции. Для преобразования используются специальные методы:

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

Для перехода от текста к числу используются Integer.parseInt / Double.parseDouble. Если строка не является корректным числом (например, "hello"), эти методы выбрасывают NumberFormatException. Для перехода от числа к тексту используйте String.valueOf(n) или просто выполните конкатенацию с "" — потому что n + "" заставляет int стать String. Обратите внимание на разницу между "5" + 1 (что даёт строку "51") и 5 + 1 (что даёт 6); + означает конкатенацию в тот момент, когда задействована String.

Приведение объектов

Приведение применяется также к ссылкам на объекты, а не только к примитивам. Вы можете привести ссылку к родственному типу по цепочке наследования — расширение до родительского типа происходит автоматически, а обратное сужение требует явного приведения и безопасно только если объект действительно относится к этому типу:

Object o = "hello";
String s = (String) o;        // OK: o действительно ссылается на String
Integer bad = (Integer) o;    // компилируется, но во время выполнения выбрасывает ClassCastException

Второе приведение компилируется, но падает во время выполнения с ClassCastException, потому что объект — это String, а не Integer. По-настоящему вы столкнётесь с этим, когда дойдёте до наследования и полиморфизма; пока же достаточно знать, что синтаксис (Type) — это та же идея, применённая к объектам.

Далее: if-else

Приведение позволяет преобразовывать значения; следующий шаг — заставить вашу программу выбирать между путями на основе этих значений. Оператор if-else выполняет один блок, когда условие истинно, и другой, когда оно ложно — основа любого решения, которое принимает ваш код. Это следующая страница.