Глава 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-битным двоичным форматом float и 64-битным двоичным форматом double для значений и операций IEEE 754, как указано в стандарте IEEE 754 (§1.7).

В Java SE 15 и более поздних версиях язык программирования Java использует версию стандарта IEEE 754 2019 года. В версиях Java SE до Java SE 15 язык программирования Java использовал версию стандарта IEEE 754 1985 года, где формат binary32 был известен как формат single, а формат binary64 — как формат 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 для каждого из его форматов чисел с плавающей точкой binary32 и binary64. Однако платформа 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 — false. Другие операции могут различать положительный и отрицательный ноль; например, 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). Эта работа сама по себе опирается на более ранние работы Крстен Торупа и Мадса Торгерсена (Unifying Genericity, ECOOP 99), а также на богатую традицию работы над вариативностью на основе объявлений, которая восходит к работам Пьера Америки по POOL (OOPSLA 89).

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

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

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).

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

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

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

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

Синтетическая переменная типа — это переменная типа, введенная компилятором во время преобразования захвата (§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;
    }
}