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

Язык программирования 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 бита и двойной точностью 64 бита IEEE 754, как указано в Стандарте IEEE для двоичной арифметики с плавающей точкой, ANSI/IEEE Standard 754-1985 (IEEE, Нью-Йорк).

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

Каждая реализация языка программирования Java обязана поддерживать два стандартных набора значений с плавающей точкой, называемые множеством значений float и множеством значений double. Кроме того, реализация языка программирования Java может поддерживать один или оба расширенных множества значений с плавающей точкой с расширенным порядком, называемые множеством значений float-extended-exponent и множеством значений double-extended-exponent. Эти множества значений с расширенным порядком могут в определенных случаях использоваться вместо стандартных множеств значений для представления значений выражений типа float или double (§5.1.13, §15.4).

Все конечные отличные от нуля значения любого множества значений с плавающей точкой могут быть выражены в форме s · m · 2^{(e - N + 1)}, где s равно +1 или -1, m — положительное целое число, меньшее 2^N, а e — целое число между E_min = -(2^K-1-2) и E_max = 2^K-1-1 включительно, а N и K — параметры, зависящие от множества значений. Некоторые значения могут быть представлены в этой форме более чем одним способом; например, предположим, что значение v в множестве значений может быть представлено в этой форме с определенными значениями для s, m и e, тогда, если m было чётным, а e меньше 2^K-1, можно уменьшить m вдвое и увеличить e на 1, чтобы получить второе представление для того же значения v. Представление в этой форме называется нормализованным, если m ≥ 2^N-1; в противном случае представление называется денормализованным. Если значение в множестве значений не может быть представлено таким образом, что m ≥ 2^N-1, то значение считается денормализованным значением, так как у него нет нормализованного представления.

Ограничения на параметры N и K (и на производные параметры E_min и E_max) для двух требуемых и двух необязательных множеств значений с плавающей точкой приведены в таблице 4.1.

Если реализация поддерживает одно или оба расширенных множества значений с плавающей точкой, то для каждого поддерживаемого множества значений с расширенным порядком существует специфическая константа K, значение которой ограничено таблицей 4.1; это значение K в свою очередь определяет значения для E_min и E_max.

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

Обратите внимание, что ограничения в таблице 4.1 разработаны таким образом, чтобы каждый элемент множества значений float обязательно также являлся элементом множества значений float-extended-exponent, double и double-extended-exponent. Аналогично, каждый элемент множества значений double обязательно также является элементом множества значений double-extended-exponent. Каждое множество значений с расширенным порядком имеет больший диапазон значений показателя, чем соответствующее стандартное множество значений, но не имеет большей точности.

Элементы множества значений float — это в точности те значения, которые могут быть представлены с использованием формата одинарной точности, определённого в стандарте IEEE 754. Элементы множества значений double — это в точности те значения, которые могут быть представлены с использованием формата двойной точности, определённого в стандарте IEEE 754. Однако элементы множеств значений float-extended-exponent и double-extended-exponent, определённые здесь, не соответствуют значениям, которые могут быть представлены с использованием форматов IEEE 754 single extended и double extended соответственно.

Множества значений float, float-extended-exponent, double и double-extended-exponent не являются типами. Для реализации языка программирования Java всегда корректно использовать элемент множества значений float для представления значения типа float; однако в некоторых областях кода реализация может использовать элемент множества значений float-extended-exponent вместо этого. Аналогично, для реализации всегда корректно использовать элемент множества значений double для представления значения типа double; однако в некоторых областях кода реализация может использовать элемент множества значений double-extended-exponent вместо этого.

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

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

В основном платформа Java SE обрабатывает значения NaN данного типа так, как будто они сводятся к одному каноническому значению, и поэтому в этом спецификации обычно упоминается произвольное NaN как каноническое значение.

Однако версия 1.3 платформы Java SE представила методы, позволяющие программисту различать значения 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).

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

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

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

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

Язык программирования Java требует, чтобы арифметика с плавающей точкой работала так, как будто каждый оператор с плавающей точкой округлял свой результат до точности результата. Неточные результаты должны быть округлены до ближайшего представимого значения к бесконечно точному результату; если два ближайших представимых значения одинаково близки, выбирается значение с нулевым младшим битом. Это стандартное округлениe 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 и Boolean могут использоваться в операторах управления потоком и в качестве первого операнда условного оператора ? :.

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

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

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

Разрешается приведение значения типа boolean к типу boolean или Boolean (§5.1.1, §5.1.7). Другие приведения для типа boolean не допускаются.

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

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

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

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

Новый экземпляр класса неявно создается, когда используется оператор конкатенации строк + (§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) и их аргументы типа, если таковые имеются, одинаковы, применяя это определение рекурсивно.

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

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

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

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

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

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

? extends B

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

? super B

boolean addAll(Collection<? extends E> c)

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

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

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

Говорят, что аргумент типа 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).

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

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

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

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

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

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

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

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

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

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

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

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

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

Загрязнение кучи может произойти только в том случае, если программа выполнила некоторую операцию, связанную с необработанным типом, что приведет к предупреждению о невыверенном преобразовании во время компиляции (§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), или если программа использует alias переменной массива с нереализуемым типом элемента через переменную массива супертипа, которая является необработанной или непараметризованной.

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 может служить полезной документацией, указывающей, что её значение не будет меняться, и может помочь избежать ошибок программирования.

Это ошибка времени компиляции, если переменная типа final присваивается значение, если она не явным образом не инициализирована (§16) непосредственно перед присваиванием.

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

После того, как переменная типа final была присвоена значение, она всегда содержит то же значение. Если переменная типа 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);
}

Переменная примитивного типа или типа String, которая является final и инициализируется константным выражением времени компиляции (§15.28), называется константной переменной.

То, является ли переменная константной переменной или нет, может иметь последствия в отношении инициализации класса (§12.4.1), бинарной совместимости (§13.1, §13.4.9) и определённого присваивания (§16).

Ресурс оператора try-с-ресурсами (§14.20.3) и параметр исключения много-catch блока (§14.20) неявно объявляются final.

Параметр исключения одно-catch блока (§14.20) может быть эффективно 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;
    }
}