Глава 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).

Булевы операторы:

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

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

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

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

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

Булевое значение boolean может быть преобразовано в строковое значение String путём преобразования в строку (§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;
    }
}