Глава 4. Типы, значения и переменные

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

Язык программирования 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

Типы с плавающей точкой представляют собой float и double, которые концептуально связаны с 32-битными двоичными 32-битными и 64-битными двоичными 64-битными форматами чисел с плавающей точкой для значений и операций IEEE 754, как указано в стандарте IEEE 754 (§1.7).

В Java SE 15 и более поздних версиях язык программирования Java использует версию IEEE 754 2019 года. До Java SE 15 язык программирования Java использовал версию IEEE 754 1985 года, где двоичный 32-битный формат был известен как формат single, а двоичный 64-битный формат — как формат double.

Стандарт IEEE 754 включает не только положительные и отрицательные числа, состоящие из знака и модуля, но также положительные и отрицательные нули, положительные и отрицательные бесконечности и специальные значения Not-a-Number (в дальнейшем сокращенно NaN). Значение NaN используется для представления результата некоторых недопустимых операций, таких как деление нуля на ноль. Постоянные NaN типов как float, так и double определены как Float.NaN и Double.NaN.

Конечные ненулевые значения типа с плавающей точкой могут быть представлены в виде s ⋅ m ⋅ 2^{(e - N + 1)}, где:

Некоторые значения могут быть представлены в этой форме более чем одним способом. Например, предположим, что значение v типа с плавающей точкой может быть представлено в этой форме с использованием определенных значений для s, m и e, а затем, если m было чётным, а e было меньше 2^K-1, можно было бы разделить m на 2 и увеличить e на 1, чтобы получить второе представление для того же значения v.

Представление в этом виде называется нормализованным, если m ≥ 2^N-1; в противном случае представление называется субнормальным. Если значение типа с плавающей точкой не может быть представлено таким образом, что m ≥ 2^N-1, то это значение называется субнормальным значением, потому что его величина ниже величины наименьшего нормализованного значения.

Ограничения на параметры N и K (и на производные параметры E_min и E_max) для float и double суммированы в таблице 4.2.3-A.

За исключением NaN, значения с плавающей точкой упорядочены. Упорядоченные от наименьшего к наибольшему: минус бесконечность, отрицательные конечные ненулевые значения, положительный и отрицательный ноль, положительные конечные ненулевые значения и плюс бесконечность.

IEEE 754 допускает несколько различных значений NaN для каждого из его двоичных 32-битных и двоичных 64-битных форматов с плавающей точкой. Однако платформа Java SE обычно рассматривает значения NaN заданного типа с плавающей точкой как сжатые в одно каноническое значение, и поэтому данное описание обычно ссылается на произвольное NaN, как на каноническое значение.

Согласно IEEE 754, операция с плавающей точкой с аргументами, не являющимися NaN, может сгенерировать результат NaN. IEEE 754 определяет набор шаблонов битов NaN, но не предписывает, какой конкретный шаблон битов NaN используется для представления результата NaN; это зависит от архитектуры аппаратного обеспечения. Программист может создавать NaN с разными шаблонами битов для кодирования, например, ретроспективных диагностических данных. Эти значения NaN могут быть созданы с помощью методов Float.intBitsToFloat и Double.longBitsToDouble для float и double соответственно. И наоборот, для проверки шаблонов битов NaN можно использовать методы Float.floatToRawIntBits и Double.doubleToRawLongBits для float и double соответственно.

Положительный и отрицательный ноль сравниваются как равные, поэтому результат выражения 0.0==-0.0 равен true, а результат 0.0>-0.0 — ложно. Другие операции могут различать положительный и отрицательный ноль; например, 1.0/0.0 имеет значение плюс бесконечность, а значение 1.0/-0.0 — минус бесконечность.

NaN является неупорядоченным, поэтому:

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

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

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

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

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

Арифметика с плавающей точкой выполняется в соответствии с правилами стандарта IEEE 754, включая переполнение и недополнение (§15.4), за исключением оператора остатка % (§15.17.3).

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

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

Оператор с плавающей точкой может выбросить исключение (§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.0E308*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 также определяет, какое подвыражение вычисляется в условном операторе ? : (§15.25).

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

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

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

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

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

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

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

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

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

Другие выражения могут неявно создавать экземпляр класса (§12.5) или массив (§10.6).

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 initializer: */
        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) и текстовые блоки (§3.10.6) являются ссылками на экземпляры класса String.

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

Два типа ссылок являются одинаковыми на этапе компиляции, если они объявлены в единицах компиляции, связанных с одним и тем же модулем (§7.3), и имеют одинаковое бинарное имя (§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>.

Исторически дикие карты — это прямой потомок работы Ацуси Игараси и Мирко Вироли. Читателям, заинтересованным в более подробном обсуждении, следует обратиться к работе On Variance-Based Subtyping for Parametric Types Ацуси Игараси и Мирко Вироли, в Трудах 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 являются все следующие:

Учитывая параметризованный класс или интерфейс C с параметрами типа F₁,...,F_n (n > 0), прямыми надтипами необработанного типа C (§4.8) являются все следующие:

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

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

Прямые надтипы типа пересечения T₁ & ... & T_n — это T_i (1 ≤ i ≤ n).

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

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

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

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

Синтетическая переменная типа — это переменная типа, вводимая компилятором во время преобразования захвата (§5.1.10) или разрешения переменной вывода (§18.4).

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

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

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

Восходящая проекция типа T относительно набора ограниченных переменных типа определяется следующим образом:

Нисходящая проекция типа T относительно набора ограниченных переменных типа — это частичная функция, определяемая следующим образом:

Как и lub (§4.10.4), восходящая и нисходящая проекции могут создавать бесконечные типы из-за рекурсии по границам переменных типа.

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

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

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

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

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

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

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

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

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

Загрязнение кучи может произойти только в том случае, если программа выполнила некоторую операцию, связанную с сырым типом, которая приведет к предупреждению о не проверенной во время компиляции ошибке (§4.8, §5.1.6, §5.1.9, §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;
    }
    boolean equalAtX(Object o) {
        if (o instanceof Point p)  // p is a pattern variable
            return this.x == p.x;
        else
            return false;
    }
}

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

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

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

Константная переменная — это final переменная примитивного типа или типа String, которая инициализируется константным выражением (§15.29). Является ли переменная константной или нет, может иметь последствия для инициализации класса (§12.4.1), бинарной совместимости (§13.1), достижимости (§14.22) и явного присваивания (§16.1.1).

Три вида переменных неявно объявляются final: поле интерфейса (§9.3), локальная переменная, объявленная как ресурс в операторе try-с-ресурсами (§14.20.3) и параметр исключения в блоке многократного catch (§14.20). Параметр исключения в блоке однократного catch никогда неявно не объявляется 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 удаляется.

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

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