Значения целочисленных типов — это целые числа в следующих диапазонах:

Язык программирования Java предоставляет ряд операторов, которые действуют на целочисленные значения:

Другие полезные конструкторы, методы и константы определены в классах Byte, Short, Integer, Long и Character.

Если целочисленный оператор, кроме оператора сдвига, имеет хотя бы один операнд типа long, то операция выполняется с 64-битной точностью, и результат числового оператора имеет тип long. Если другой операнд не является long, то он предварительно расширяется (§5.1.5) до типа long с помощью числового продвижения (§5.6).

В противном случае операция выполняется с 32-битной точностью, и результат числового оператора имеет тип int. Если какой-либо из операндов не является int, то он предварительно расширяется до типа int с помощью числового продвижения.

Любое значение любого целочисленного типа может быть приведено к любому числовому типу или из него. Преобразований между целочисленными типами и типом boolean нет.

См. §4.2.5 для примера преобразования целочисленных выражений в boolean.

Операторы целых чисел не указывают переполнение или недополнение никоим образом.

Целочисленный оператор может генерировать исключение (§11 (Исключения)) по следующим причинам:

class Test {
    public static void main(String[] args) {
        int i = 1000000;
        System.out.println(i * i);
        long l = i;
        System.out.println(l * l);
        System.out.println(20296 / (l - i));
    }
}

-727379968
1000000000000

Язык программирования Java предоставляет ряд операторов, действующих на значения с плавающей запятой:

Другие полезные конструкторы, методы и константы определены в классах Float, Double и Math.

Если хотя бы один из операндов бинарного оператора имеет тип с плавающей запятой, то операция является операцией с плавающей запятой, даже если другой является целочисленным.

Если хотя бы один из операндов числового оператора имеет тип double, то операция выполняется с использованием 64-битной арифметики с плавающей запятой, а результат числового оператора — значение типа double. Если другой операнд не является double, он сначала расширяется (§5.1.5) до типа double с помощью числового повышения (§5.6).

В противном случае операция выполняется с использованием 32-битной арифметики с плавающей запятой, а результат числового оператора — значение типа float. (Если другой операнд не является float, он сначала расширяется до типа float с помощью числового повышения.)

Любое значение типа с плавающей запятой может быть приведено к любому числовому типу или из него. Не существует приведений между типами с плавающей запятой и типом boolean.

См. §4.2.5 для примера преобразования выражений с плавающей запятой в boolean.

Операторы над числами с плавающей запятой ведут себя в соответствии со спецификацией IEEE 754 (за исключением оператора остатка (§15.17.3)). В частности, язык программирования Java требует поддержки IEEE 754 нормализованных чисел с плавающей запятой и постепенного переполнения, что упрощает доказательство желаемых свойств конкретных числовых алгоритмов. Операции с плавающей запятой не «обнуляются» при получении нормализованного числа в результате.

Язык программирования Java требует, чтобы арифметика с плавающей запятой вела себя так, как если бы каждый оператор с плавающей запятой округлял свой результат до точности результата. Неточные результаты должны быть округлены до ближайшего представимого значения к бесконечно точному результату; если два ближайших представимых значения одинаково близки, выбирается значение с нулевым младшим битом. Это стандартный режим округления IEEE 754, известный как округление до ближайшего.

Язык программирования Java использует округление к нулю при преобразовании значения с плавающей запятой в целое число (§5.1.3), что в этом случае действует так, как если бы число было усечено, отбрасывая биты мантиссы. Округление к нулю выбирает в качестве результата значение формата, наиболее близкое к бесконечно точному результату и не превышающее его по величине.

Операция с плавающей запятой, которая переполняет, приводит к значению бесконечности с соответствующим знаком.

Операция с плавающей запятой, которая недополняет, приводит к нормализованному значению или значению нуля с соответствующим знаком.

Операция с плавающей запятой, которая не имеет математически определенного результата, приводит к NaN.

Все числовые операции с NaN в качестве операнда дают NaN в качестве результата.

Оператор с плавающей запятой может вызвать исключение (§11 (Исключения)) по следующим причинам:

class Test {
    public static void main(String[] args) {
        // An example of overflow:
        double d = 1e308;
        System.out.print("overflow produces infinity: ");
        System.out.println(d + "*10==" + d*10);
        // An example of gradual underflow:
        d = 1e-305 * Math.PI;
        System.out.print("gradual underflow: " + d + "\n   ");
        for (int i = 0; i < 4; i++)
            System.out.print(" " + (d /= 100000));
        System.out.println();
        // An example of NaN:
        System.out.print("0.0/0.0 is Not-a-Number: ");
        d = 0.0/0.0;
        System.out.println(d);
        // An example of inexact results and rounding:
        System.out.print("inexact results with float:");
        for (int i = 0; i < 100; i++) {
            float z = 1.0f / i;
            if (z * i != 1.0f)
                System.out.print(" " + i);
        }
        System.out.println();
        // Another example of inexact results and rounding:
        System.out.print("inexact results with double:");
        for (int i = 0; i < 100; i++) {
            double z = 1.0 / i;
            if (z * i != 1.0)
                System.out.print(" " + i);
        }
        System.out.println();
        // An example of cast to integer rounding:
        System.out.print("cast to int rounds toward 0: ");
        d = 12345.6;
        System.out.println((int)d + " " + (int)(-d));
    }
}

overflow produces infinity: 1.0e+308*10==Infinity
gradual underflow: 3.141592653589793E-305
3.1415926535898E-310 3.141592653E-315 3.142E-320 0.0
0.0/0.0 is Not-a-Number: NaN
inexact results with float: 0 41 47 55 61 82 83 94 97
inexact results with double: 0 49 98
cast to int rounds toward 0: 12345 -12345

Тип boolean представляет логическое значение с двумя возможными значениями, которые указываются литералами true и false (§3.10.3).

Операторы для boolean:

Выражения boolean определяют поток управления в различных типах операторов:

Выражение boolean также определяет, какое подвыражение вычисляется в условном операторе ?: (§15.25).

Только выражения boolean и int могут использоваться в операторах управления потоком и в качестве первого операнда условного оператора ?.

Выражение целого или вещественного типа может быть преобразовано в значение boolean, в соответствии с соглашениями языка C, где любое ненулевое значение — это true, с помощью выражения x!=0.

Ссылка на объект может быть преобразована в значение boolean, в соответствии с соглашениями языка C, где любая ссылка, отличная от null, — это true, с помощью выражения obj!=null.

Значение boolean может быть преобразовано в строку с помощью преобразования в строку (§5.4).

Значение boolean может быть приведено к типу int, float или long (§5.5). Другие приведения типов для типа boolean недопустимы.

Объект — это экземпляр класса или массив.

Значения ссылок (часто просто ссылки) являются указателями на эти объекты, и специальной ссылкой null, которая не ссылается ни на какой объект.

Экземпляр класса явно создаётся с помощью выражения создания экземпляра класса (§15.9).

Массив явно создаётся с помощью выражения создания массива (§15.10.1).

Новый экземпляр класса неявно создаётся, когда используется оператор конкатенации строк + (§15.18.1) в неконстантном выражении (§15.28), что приводит к созданию нового объекта типа String (§4.3.3).

Новый объект массива неявно создаётся, когда вычисляется выражение инициализатора массива (§10.6); это может произойти при инициализации класса или интерфейса (§12.4), при создании нового экземпляра класса (§15.9) или при выполнении оператора объявления локальной переменной (§14.4).

Новые объекты типов Boolean, Byte, Short, Character, Integer, Long, Float и Double могут быть неявно созданы при преобразовании в ящике (§5.1.7).

class Point {
    int x, y;
    Point() { System.out.println("default"); }
    Point(int x, int y) { this.x = x; this.y = y; }

    /* A Point instance is explicitly created at 
       class initialization time: */
    static Point origin = new Point(0,0);

    /* A String can be implicitly created 
       by a + operator: */
    public String toString() { return "(" + x + "," + y + ")"; }
}

class Test {
    public static void main(String[] args) {
        /* A Point is explicitly created
           using newInstance: */
        Point p = null;
        try {
            p = (Point)Class.forName("Point").newInstance();
        } catch (Exception e) {
            System.out.println(e);
        }

        /* An array is implicitly created 
           by an array constructor: */
        Point a[] = { new Point(0,0), new Point(1,1) };

        /* Strings are implicitly created 
           by + operators: */
        System.out.println("p: " + p);
        System.out.println("a: { " + a[0] + ", " + a[1] + " }");
    
        /* An array is explicitly created
           by an array creation expression: */
        String sa[] = new String[2];
        sa[0] = "he"; sa[1] = "llo";
        System.out.println(sa[0] + sa[1]);
    }
}

default
p: (0,0)
a: { (0,0), (1,1) }
hello

Операторы над ссылками на объекты:

Может быть много ссылок на один и тот же объект. Большинство объектов имеют состояние, хранящееся в полях объектов, являющихся экземплярами классов, или в переменных, являющихся компонентами объекта массива. Если две переменные содержат ссылки на один и тот же объект, состояние объекта может быть изменено с помощью ссылки одной переменной на объект, а затем изменённое состояние может быть просмотрено через ссылку в другой переменной.

class Value { int val; }

class Test {
    public static void main(String[] args) {
        int i1 = 3;
        int i2 = i1;
        i2 = 4;
        System.out.print("i1==" + i1);
        System.out.println(" but i2==" + i2);
        Value v1 = new Value();
        v1.val = 5;
        Value v2 = v1;
        v2.val = 6;
        System.out.print("v1.val==" + v1.val);
        System.out.println(" and v2.val==" + v2.val);
    }
}

i1==3 but i2==4
v1.val==6 and v2.val==6

Каждый объект связан с монитором (§17.1), который используется методами synchronized (§8.4.3) и оператором synchronized (§14.19) для управления одновременным доступом к состоянию несколькими потоками (§17 (Потоки и блокировки)).

Класс Object является суперклассом (§8.1.4) всех остальных классов.

Все типы классов и массивов наследуют (§8.4.8) методы класса Object, которые обобщаются следующим образом:

Экземпляры класса String представляют последовательности кодовых точек Юникода.

Объект String имеет постоянное (неизменяемое) значение.

Строковые литералы (§3.10.5) являются ссылками на экземпляры класса String.

Оператор конкатенации строк + (§15.18.1) неявно создаёт новый объект String, когда результат не является константным выражением (§15.28).

Два типа ссылок являются одинаковыми типами на этапе компиляции, если у них одинаковое двоичное имя (§13.1) и их аргументы типа, если таковые имеются, одинаковы, применяя это определение рекурсивно.

Когда два типа ссылок одинаковы, их иногда называют одним и тем же классом или одним и тем же интерфейсом.

Во время выполнения несколько типов ссылок с одинаковым двоичным именем могут быть загружены одновременно различными загрузчиками классов. Эти типы могут или не могут представлять одну и ту же декларацию типа. Даже если два таких типа представляют одну и ту же декларацию типа, они считаются различными.

Два типа ссылок являются одинаковыми типами во время выполнения, если:

Аргументы типа могут быть либо типами ссылок, либо джойлд-карами. Джойлд-кары полезны в ситуациях, когда требуется только частичная информация об аргументе типа.

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

? extends B

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

? super B

Джойлд-кар ? extends Object эквивалентен не ограниченному джойлд-кару ?.

Два аргумента типа доказуемо различны, если выполняется одно из следующих условий:

Аргумент типа T₁ считается содержащим другой аргумент типа T₂, записываемый как T₂ <= T₁, если множество типов, обозначаемых T₂, доказуемо является подмножеством множества типов, обозначаемых T₁, в соответствии с рефлексивным и транзитивным замыканием следующих правил (где <: обозначает подтипирование (§4.10)):

Отношение джойлд-каров к установленной теории типов — интересный вопрос, который мы кратко затронем здесь. Джойлд-кары — это ограниченная форма экзистенциальных типов. При задании общего объявления типа G<T extends B>, G<?> примерно аналогично Some X <: B. G<X>.

Исторически джойлд-кары являются прямыми потомками работ Ацуши Игараши и Мирко Вироли. Читатели, заинтересованные в более подробном обсуждении, должны обратиться к статье О подтипировании на основе вариативности для параметризованных типов Ацуши Игараши и Мирко Вироли в Трудах 16-й европейской конференции по объектно-ориентированному программированию (ECOOP 2002). Эта работа сама по себе основана на более ранних работах Крёстэна Торупа и Мадса Торгэрсена (Объединение обобщений, ECOOP 99), а также на богатой традиции работы над вариативностью на основе объявлений, уходящей корнями к работе Пьера Америки над POOL (OOPSLA 89).

Джойлд-кары отличаются в некоторых деталях от конструкций, описанных в упомянутой статье, в частности, в использовании преобразования захвата (§5.1.10) вместо операции close, описанной Игараши и Вироли. Более формальное описание джойлд-каров см. в Wild FJ Мадса Торгэрсена, Эрика Эрнста и Кристиана Плезнера Хэнсена в 12-м семинаре по основам объектно-ориентированного программирования (FOOL 2005).

import java.util.Collection;
import java.util.ArrayList;

class Test {
    static void printCollection(Collection<?> c) {
                                // a wildcard collection
        for (Object o : c) {
            System.out.println(o);
        }
    }

    public static void main(String[] args) {
        Collection<String> cs = new ArrayList<String>();
        cs.add("hello");
        cs.add("world");
        printCollection(cs);
    }
}

public Method getMethod(Class<?>[] parameterTypes) { ... }

boolean addAll(Collection<? extends E> c)

<T> boolean addAll(Collection<T> c)

Reference(T referent, ReferenceQueue<? super T> queue)

Пусть C — объявление обобщённого класса или интерфейса с параметрами типов A₁,...,A_n, и пусть C<T₁,...,T_n> — параметризация C, где для 1 ≤ i ≤ n, T_i — тип (а не подстановочный символ). Тогда:

Если какие-либо аргументы типа в параметризации C являются подстановочными символами, то:

Это не имеет значения, так как невозможно получить доступ к члену параметризованного типа без выполнения преобразования захвата, и невозможно использовать подстановочный символ после ключевого слова new в выражении создания экземпляра класса (§15.9).

Единственное исключение из предыдущего абзаца — это когда вложенный параметризованный тип используется как выражение в операторе instanceof (§15.20.2), где преобразование захвата не применяется.

Член static, объявленный в обобщённом объявлении типа, должен ссылаться с использованием необобщённого типа, соответствующего обобщённому типу (§6.1, §6.5.5.2, §6.5.6.2), или возникает ошибка компиляции.

Другими словами, недопустимо ссылаться на член static, объявленный в обобщённом объявлении типа, используя параметризованный тип.

Следующие правила определяют отношение прямого надтипа между примитивными типами:

Учитывая объявление недженерик типа C, прямыми супертипами типа C являются все следующие:

Учитывая объявление generic типа C<F₁,...,F_n> (n > 0), прямыми супертипами raw типа C (§4.8) являются все следующие:

Учитывая объявление generic типа C<F₁,...,F_n> (n > 0), прямыми супертипами generic типа C<F₁,...,F_n> являются все следующие:

Учитывая объявление generic типа C<F₁,...,F_n> (n > 0), прямыми супертипами параметризованного типа C<T₁,...,T_n>, где T_i (1 ≤ i ≤ n) является типом, являются все следующие:

Учитывая объявление generic типа C<F₁,...,F_n> (n > 0), прямыми супертипами параметризованного типа C<R₁,...,R_n>, где по крайней мере один из R_i (1 ≤ i ≤ n) является аргументом типа wildcard, являются прямыми супертипами параметризованного типа C<X₁,...,X_n>, который является результатом применения преобразования захвата к C<R₁,...,R_n> (§5.1.10).

Прямые супертипы пересекающегося типа T₁ & ... & T_n являются T_i (1 ≤ i ≤ n).

Прямые супертипы переменной типа - это типы, перечисленные в ее границе.

Переменная типа является прямым супертипом своей нижней границы.

Прямые супертипы null типа - все ссылочные типы, кроме самого null типа.

Следующие правила определяют отношение прямого супертипа среди типов массивов:

Переменная примитивного типа всегда содержит примитивное значение того же самого примитивного типа.

Переменная типа класса T может содержать нулевую ссылку или ссылку на экземпляр класса T или любого класса, являющегося подклассом T.

Переменная типа интерфейса может содержать нулевую ссылку или ссылку на любой экземпляр любого класса, реализующего интерфейс.

Обратите внимание, что переменная не гарантированно всегда ссылается на подтип своего объявленного типа, а только на подклассы или подинтерфейсы объявленного типа. Это связано с возможностью загрязнения кучи, обсуждаемой ниже.

Если T является примитивным типом, то переменная типа «массив из T» может содержать нулевую ссылку или ссылку на любой массив типа «массив из T».

Если T является ссылочным типом, то переменная типа «массив из T» может содержать нулевую ссылку или ссылку на любой массив типа «массив из S», где тип S является подклассом или подинтерфейсом типа T.

Переменная типа Object[] может содержать ссылку на массив любого ссылочного типа.

Переменная типа Object может содержать нулевую ссылку или ссылку на любой объект, будь то экземпляр класса или массив.

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

Загрязнение кучи может произойти только в том случае, если программа выполнила какую-либо операцию, связанную с сырым типом, которая привела бы к предупреждению о невыполненной проверке во время компиляции (§4.8, §5.1.9, §5.5.2, §8.4.1, §8.4.8.3, §8.4.8.4, §9.4.1.2, §15.12.4.2), или если программа алиасирует переменную массива с нереализуемым типом элемента через переменную массива сверхтипа, который является либо сырым, либо негенерическим.

List l = new ArrayList<Number>();
List<String> ls = l;  // Unchecked warning

static void m(List<String>... stringLists) {
    Object[] array = stringLists;
    List<Integer> tmpList = Arrays.asList(42);
    array[0] = tmpList;                // (1)
    String s = stringLists[0].get(0);  // (2)
}

Переменная всегда будет ссылаться на объект, который является экземпляром класса, представляющего параметризованный тип.

Значение ls в приведённом выше примере всегда является экземпляром класса, предоставляющего представление List.

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

Если никакая операция, требующая выдачи предупреждения о невыполненной проверке во время компиляции, не выполняется, и не происходит небезопасного алиасинга переменных массивов с нереализуемыми типами элементов, то загрязнение кучи не может произойти. Обратите внимание, что это не означает, что загрязнение кучи происходит только в том случае, если произошло предупреждение о невыполненной проверке. Можно запустить программу, где некоторые двоичные файлы были созданы компилятором более старой версии языка программирования Java или из источников, которые явно подавили предупреждения о невыполненной проверке. Эта практика в лучшем случае небезопасна.

Напротив, возможно, что, несмотря на выполнение кода, который мог (и, возможно, и сделал) привести к предупреждению о невыполненной проверке во время компиляции, загрязнение кучи не происходит. Действительно, хорошая практика программирования требует, чтобы программист убедился, что, несмотря на любые предупреждения о невыполненной проверке, код корректен и загрязнение кучи не произойдёт.

Существует восемь видов переменных:

class Point {
    static int numPoints;   // numPoints is a class variable
    int x, y;               // x and y are instance variables
    int[] w = new int[10];  // w[0] is an array component
    int setX(int x) {       // x is a method parameter
        int oldx = this.x;  // oldx is a local variable
        this.x = x;
        return oldx;
    }
}

Переменная может быть объявлена final. Переменная final может быть присвоена только один раз. Если переменная final получает присвоение, это будет ошибкой компиляции, за исключением случаев, когда она определенно не инициализирована непосредственно перед присваиванием (§16 (Определённая инициализация)).

После присвоения значения переменной final, она всегда содержит то же значение. Если переменная final содержит ссылку на объект, то состояние объекта может быть изменено операциями над объектом, но переменная всегда будет ссылаться на тот же объект. Это относится и к массивам, поскольку массивы являются объектами; если переменная final содержит ссылку на массив, то компоненты массива могут быть изменены операциями над массивом, но переменная всегда будет ссылаться на тот же массив.

Пустая final - это final переменная, объявление которой не содержит инициализатора.

Постоянная переменная - это final переменная примитивного типа или типа String, которая инициализируется константным выражением (§15.28). То, является ли переменная постоянной, может иметь последствия для инициализации классов (§12.4.1), бинарной совместимости (§13.1, §13.4.9) и определённой инициализации (§16 (Определённая инициализация)).

Три вида переменных неявно объявляются final: поле интерфейса (§9.3), локальная переменная, которая является ресурсом оператора try-with-resources (§14.20.3), и параметр исключения в много-catch операторе (§14.20). Параметр исключения в одно-catch операторе никогда не неявно объявляется final, но может быть эффективным final.

class Point {
    int x, y;
    int useCount;
    Point(int x, int y) { this.x = x; this.y = y; }
    static final Point origin = new Point(0, 0);
}

Некоторые переменные, которые не объявлены final, считаются эффективно final:

Если переменная является эффективно final, добавление модификатора final к её объявлению не вызовет ошибок компиляции. И наоборот, локальная переменная или параметр, объявленный final в корректной программе, становится эффективным final, если модификатор final удаляется.

Каждая переменная в программе должна иметь значение до её использования:

class Point {
    static int npoints;
    int x, y;
    Point root;
}

class Test {
    public static void main(String[] args) {
        System.out.println("npoints=" + Point.npoints);
        Point p = new Point();
        System.out.println("p.x=" + p.x + ", p.y=" + p.y);
        System.out.println("p.root=" + p.root);
    }
}

npoints=0
p.x=0, p.y=0
p.root=null

В языке программирования Java каждая переменная и каждое выражение имеют тип, который может быть определен на этапе компиляции. Тип может быть примитивным типом или ссылочным типом. Ссылочные типы включают типы классов и типы интерфейсов. Ссылочные типы вводятся с помощью объявлений типов, которые включают объявления классов (§8.1) и объявления интерфейсов (§9.1). Мы часто используем термин тип для обозначения класса или интерфейса.

В виртуальной машине Java каждый объект принадлежит какому-то конкретному классу: классу, который был упомянут в выражении создания, которое произвело объект (§15.9), или классу, чьё Class объект был использован для вызова рефлексивного метода для создания объекта, или String классу для объектов, неявно созданных оператором конкатенации строк + (§15.18.1). Этот класс называется классом объекта. Говорят, что объект является экземпляром своего класса и всех его суперклассов.

Каждый массив также имеет класс. Метод getClass, когда вызывается для объекта массива, вернёт объект класса Class, который представляет класс массива (§10.8).

Тип переменной на этапе компиляции всегда объявляется, а тип выражения на этапе компиляции может быть выведен на этапе компиляции. Тип на этапе компиляции ограничивает возможные значения, которые переменная может содержать во время выполнения, или значения, которые может произвести выражение во время выполнения. Если значение во время выполнения является ссылкой, которая не является null, оно ссылается на объект или массив, у которого есть класс, и этот класс обязательно будет совместим с типом на этапе компиляции.

Даже если переменная или выражение могут иметь тип на этапе компиляции, который является типом интерфейса, экземпляров интерфейсов не существует. Переменная или выражение, тип которых является типом интерфейса, может ссылаться на любой объект, класс которого реализует (§8.1.5) этот интерфейс.

Иногда переменная или выражение имеют "тип во время выполнения". Это относится к классу объекта, на который ссылается значение переменной или выражения во время выполнения, при условии, что значение не является null.

Соответствие между типами на этапе компиляции и типами во время выполнения неполное по двум причинам:

interface Colorable {
    void setColor(byte r, byte g, byte b);
}

class Point { int x, y; }

class ColoredPoint extends Point implements Colorable {
    byte r, g, b;
    public void setColor(byte rv, byte gv, byte bv) {
        r = rv; g = gv; b = bv;
    }
}

class Test {
    public static void main(String[] args) {
        Point p = new Point();
        ColoredPoint cp = new ColoredPoint();
        p = cp;
        Colorable c = cp;
    }
}