Глава 15. Выражения

Левый операнд бинарного оператора, по-видимому, полностью вычисляется перед любой частью правого операнда.

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

Если вычисление левого операнда бинарного оператора завершается внезапно, ни одна часть правого операнда, по-видимому, не была вычислена.

class Test1 {
    public static void main(String[] args) {
        int i = 2;
        int j = (i=3) * i;
        System.out.println(j);
    }
}

9

class Test2 {
    public static void main(String[] args) {
        int a = 9;
        a += (a = 3);  // first example
        System.out.println(a);
        int b = 9;
        b = b + (b = 3);  // second example
        System.out.println(b);
    }
}

12
12

class Test3 {
    public static void main(String[] args) {
        int j = 1;
        try {
            int i = forgetIt() / (j = 2);
        } catch (Exception e) {
            System.out.println(e);
            System.out.println("Now j = " + j);
        }
    }
    static int forgetIt() throws Exception {
        throw new Exception("I'm outta here!");
    }
}

java.lang.Exception: I'm outta here!
Now j = 1

Язык программирования Java гарантирует, что каждый операнд оператора (кроме условных операторов &&, || и ? :) вычисляется полностью, прежде чем любая часть самой операции будет выполнена.

Если бинарный оператор является оператором целочисленного деления / (§15.17.2) или целочисленным остатком % (§15.17.3), то его выполнение может вызвать ArithmeticException, но это исключение выбрасывается только после того, как оба операнда бинарного оператора были вычислены и только если эти вычисления завершились нормально.

class Test {
    public static void main(String[] args) {
        int divisor = 0;
        try {
            int i = 1 / (divisor * loseBig());
        } catch (Exception e) {
            System.out.println(e);
        }
    }
    static int loseBig() throws Exception {
        throw new Exception("Shuffle off to Buffalo!");
    }
}

java.lang.Exception: Shuffle off to Buffalo!

java.lang.ArithmeticException: / by zero

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

Реализация языка программирования Java не может использовать алгебраические тождества, такие как ассоциативный закон, для переписывания выражений в более удобном порядке вычисления, если не может быть доказано, что выражение-замена эквивалентно по значению и по наблюдаемым побочным эффектам, даже при наличии нескольких потоков выполнения (используя модель выполнения потоков в §17 (Потоки и блокировки)), для всех возможных вычислительных значений, которые могут быть вовлечены.

В случае вычислений с плавающей точкой это правило также применяется к бесконечности и значениям не-числа (NaN).

Например, !(x<y) не может быть переписан как x>=y, потому что эти выражения имеют разные значения, если либо x, либо y равны NaN, или оба равны NaN.

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

Например, неверно, чтобы компилятор Java переписывал 4.0*x*0.5 как 2.0*x; хотя здесь округление не является проблемой, существуют большие значения x, для которых первое выражение производит бесконечность (из-за переполнения), а второе выражение производит конечный результат.

class Test {
    public static void main(String[] args) {
        double d = 8E307;
        System.out.println(4.0 * d * 0.5);
        System.out.println(2.0 * d);
    }
}

Infinity
1.6E308

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

Например, a+b+c, где a, b и c являются локальными переменными (это упрощающее предположение избегает проблем, связанных с несколькими потоками и volatile переменными), всегда будет давать одинаковый ответ, независимо от того, вычисляется ли он как (a+b)+c или a+(b+c); если выражение b+c появляется поблизости в коде, умный компилятор Java может использовать эту общую подвыражение.

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

Если вычисление выражения аргумента внезапно завершается, ни одна часть выражения аргумента справа от него, по-видимому, не была вычислена.

class Test1 {
    public static void main(String[] args) {
        String s = "going, ";
        print3(s, s, s = "gone");
    }
    static void print3(String a, String b, String c) {
        System.out.println(a + b + c);
    }
}

going, going, gone

class Test2 {
    static int id;
    public static void main(String[] args) {
        try {
            test(id = 1, oops(), id = 3);
        } catch (Exception e) {
            System.out.println(e + ", id=" + id);
        }
    }
    static int test(int a, int b, int c) {
        return a + b + c;
    }
    static int oops() throws Exception {
        throw new Exception("oops");
    }
}

java.lang.Exception: oops, id=1

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

Литерал (§3.10) обозначает фиксированное, неизменное значение.

Следующая продукция из §3.10 показана здесь для удобства:

Тип литерала определяется следующим образом:

Оценка лексического литерала всегда завершается нормально.

Литерал класса — это выражение, состоящее из имени класса, интерфейса, типа массива или примитивного типа, или псевдотипа void, за которым следует '.' и токен class.

ИмяТипа должен обозначать класс или интерфейс, к которому есть доступ (§6.6). Ошибка компиляции, если ИмяТипа обозначает недоступный класс или интерфейс, или переменную типа.

Тип C.class, где C — имя класса, интерфейса или типа массива (§4.3), — это Class<C>.

Тип p.class, где p — имя примитивного типа (§4.2), — это Class<B>, где B — тип выражения типа p после преобразования к обёртке (§5.1.7).

Тип void.class (§8.4.5) — это Class<Void>.

Литерал класса вычисляет значение, представляющее объект для указанного класса, интерфейса, типа массива или примитивного типа (или для void), как определено загрузчиком классов, определяющим класс текущего экземпляра (§12.2).

Ключевое слово this может использоваться в качестве выражения в следующих контекстах:

Когда используется как выражение, ключевое слово this обозначает значение, являющееся ссылкой на объект, для которого был вызван метод экземпляра (§15.12), или на объект, который создаётся. Значение, обозначаемое this в теле лямбда-выражения (§15.27.2), такое же, как значение, обозначаемое this в окружающем контексте.

Ключевое слово this также используется в явных операциях вызова конструктора (§8.8.7.1) и для обозначения параметра получателя метода или конструктора (§8.4).

Ошибка компиляции, если выражение this встречается в статическом контексте (§8.1.3).

Пусть C — самый внутренний класс или интерфейс, окружающий выражение this. Если C является обобщённым, с параметрами типа F₁,...,F_n, тип this — C<F₁,...,F_n>. В противном случае, тип this — C.

Во время выполнения класс фактического объекта может быть C или подклассом C (§8.1.5).

class IntVector {
    int[] v;
    boolean equals(IntVector other) {
        if (this == other)
            return true;
        if (v.length != other.v.length)
            return false;
        for (int i = 0; i < v.length; i++) {
            if (v[i] != other.v[i]) return false;
        }
        return true;
    }
}

Любой лексически окружающий экземпляр (§8.1.3) может быть указан путём явного квалифицирования ключевого слова this.

Пусть n — целое число такое, что ИмяТипа обозначает n-й лексически окружающий класс или интерфейс, объявление которого непосредственно включает квалифицированное выражение this.

Значение выражения квалифицированного this ИмяТипа.this — n-й лексически окружающий экземпляр this.

Если ИмяТипа обозначает обобщённый класс с параметрами типа F₁,...,F_n, тип квалифицированного выражения this — ИмяТипа<F₁,...,F_n>. В противном случае, тип квалифицированного выражения this — ИмяТипа.

Ошибка компиляции, если квалифицированное выражение this встречается в статическом контексте (§8.1.3).

Ошибка компиляции, если класс или интерфейс, объявление которого непосредственно включает квалифицированное выражение this, не является внутренним классом ИмяТипа или ИмяТипа самим по себе.

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

Использование скобок влияет только на порядок вычисления, за исключением частного случая, когда (-2147483648) и (-9223372036854775808L) являются допустимыми, но -(2147483648) и -(9223372036854775808L) недопустимы.

Это связано с тем, что десятичные литералы 2147483648 и 9223372036854775808L разрешены только в качестве операнда унарного минуса (§3.10.1).

В частности, наличие или отсутствие скобок вокруг выражения не влияет на то, является ли переменная определённо присвоенной, определённо присвоенной, когда true, определённо присвоенной, когда false, определённо не присвоенной, определённо не присвоенной, когда true или определённо не присвоенной, когда false (§16 (Определённая присвоение)).

Если выражение в скобках появляется в контексте определённого типа с целевым типом T (§5 (Преобразования и контексты)), то и содержащееся выражение аналогичным образом появляется в контексте того же типа с целевым типом T.

Если содержащееся выражение является поливыражением (§15.2), то выражение в скобках также является поливыражением. В противном случае, это независимое выражение.

Поливыражение в скобках совместимо с целевым типом T, если содержащееся выражение совместимо с T.

Если ClassOrInterfaceTypeToInstantiate заканчивается TypeArguments (а не <>), то ClassOrInterfaceTypeToInstantiate должно обозначать хорошо сформированный параметризованный тип (§4.5), иначе возникает ошибка компиляции.

Если ClassOrInterfaceTypeToInstantiate заканчивается <>, но класс или интерфейс, обозначаемый Identifier в ClassOrInterfaceTypeToInstantiate, не является обобщенным, то возникает ошибка компиляции.

Если выражение создания экземпляра класса заканчивается телом класса, то создаваемый класс — анонимный класс. Тогда:

Если выражение создания экземпляра класса не объявляет анонимный класс, то:

Пусть C — класс, который создается, а i — создаваемый экземпляр. Если C — вложенный класс, то i может иметь непосредственно окружающий экземпляр (§8.1.3), определяемый следующим образом:

Если C — анонимный класс, а его непосредственный суперкласс S — вложенный класс, то i может иметь непосредственно окружающий экземпляр относительно S, определяемый следующим образом:

Во время выполнения вычисление выражения создания экземпляра класса происходит следующим образом.

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

Далее выделяется память для нового экземпляра класса. Если памяти недостаточно для выделения объекта, вычисление выражения создания экземпляра класса завершается прерыванием сбросом исключения OutOfMemoryError.

Новый объект содержит новые экземпляры всех полей, объявленных в указанном классе и всех его суперклассах. По мере создания каждого нового экземпляра поля он инициализируется своим значением по умолчанию (§4.12.5).

Затем вычисляются фактические аргументы конструктора слева направо. Если вычисление любого из аргументов завершается прерыванием, то выражения аргументов справа от него не вычисляются, и выражение создания экземпляра класса завершается прерыванием по той же причине.

Далее вызывается выбранный конструктор указанного класса. Это приводит к вызову как минимум одного конструктора для каждого суперкласса класса. Этот процесс может быть направлен явными операторами вызова конструкторов (§8.8.7.1) и подробно описан в §12.5.

Значение выражения создания экземпляра класса — это ссылка на только что созданный объект указанного класса. Каждый раз при вычислении выражения создается новый объект.

class List {
    int value;
    List next;
    static List head = new List(0);
    List(int n) { value = n; next = head; head = this; }
}
class Test {
    public static void main(String[] args) {
        int id = 0, oldid = 0;
        try {
            for (;;) {
                ++id;
                new List(oldid = id);
            }
        } catch (Error e) {
            List.head = null;
            System.out.println(e.getClass() + ", " + (oldid==id));
        }
    }
}

class java.lang.OutOfMemoryError, false

Анонимный класс неявно объявляется выражением создания экземпляра класса или константой перечисления, которая завершается телом класса (§8.9.1).

Анонимный класс никогда не является abstract (§8.1.1.1).

Анонимный класс никогда не является sealed (§8.1.1.2), и поэтому у него нет разрешенных непосредственных подклассов (§8.1.6).

Анонимный класс, объявленный выражением создания экземпляра класса, никогда не является final (§8.1.1.2).

Анонимный класс, объявленный константой перечисления, всегда является final.

То, что анонимный класс не является final, имеет значение при приведении типов, в частности, при сужении преобразования ссылок, разрешенного оператором приведения типов (§5.5). С другой стороны, это не имеет значения для наследования, потому что невозможно объявить подкласс анонимного класса (анонимный класс не может быть назван в разделе extends), несмотря на то, что анонимный класс не является final.

Анонимный класс всегда является внутренним классом (§8.1.3).

Как и локальный класс или интерфейс (§14.3), анонимный класс не является членом любого пакета, класса или интерфейса (§7.1, §8.5).

Тип непосредственного суперкласса или тип непосредственного суперинтерфейса анонимного класса, объявленного выражением создания экземпляра класса, задаётся выражением (§15.9.1), с необходимой выводом типов аргументов при выборе конструктора (§15.9.3). Если указан тип непосредственного суперинтерфейса, тип непосредственного суперкласса является Object.

Тип непосредственного суперкласса анонимного класса, объявленного константой перечисления, — это тип объявляющего класса перечисления.

Тело класса выражения создания экземпляра класса или константы перечисления объявляет поля (§8.3), методы (§8.4), вложенные классы (§8.5), вложенные интерфейсы (§9.1.1.3), инициализаторы экземпляров (§8.6) и статические инициализаторы (§8.7) анонимного класса. Конструктор анонимного класса всегда неявный (§15.9.5.1).

Если выражение создания экземпляра класса с ClassBody использует ромб (<>) для типов аргументов создаваемого класса, то для всех методов, объявленных в ClassBody, не являющихся private, метод объявляется как будто он аннотирован с @Override (§9.6.4.4).

При использовании <>, выведенные типы аргументов могут не соответствовать ожиданиям программиста. Вследствие этого, супертип анонимного класса может не соответствовать ожиданиям, а методы, объявленные в анонимном классе, могут не переопределять методы супертипа так, как предполагалось. Обращение к таким методам, как будто они аннотированы @Override (если они не явным образом аннотированы @Override), помогает избежать неявных ошибок в программах.

Выражение создания массива используется для создания новых массивов (§10 (Массивы)).

Следующая продукция из §4.3 приведена здесь для удобства:

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

Ошибка компиляции, если ClassOrInterfaceType не обозначает реифицируемый тип (§4.7). В противном случае ClassOrInterfaceType может именовать любой именованный ссылочный тип, даже тип abstract класса (§8.1.1.1) или интерфейса.

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

Тип каждого выражения измерения в DimExpr должен быть типом, преобразуемым (§5.1.8) в целочисленный тип, в противном случае возникает ошибка компиляции.

Каждое выражение измерения подвергается численному продвижению с унарным преобразованием (§5.6). Продвинутый тип должен быть int, в противном случае возникает ошибка компиляции.

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

new double[3][3][]

double[][][]

Во время выполнения выражение создания массива ведет себя следующим образом:

class Test1 {
    public static void main(String[] args) {
        int     i  = 4;
        int[][] ia = new int[i][i=3];
        System.out.println(
            "[" + ia.length + "," + ia[0].length + "]");
    }
}

[4,3]

class Test2 {
    public static void main(String[] args) {
        int[][] a = { { 00, 01 }, { 10, 11 } };
        int i = 99;
        try {
            a[val()][i = 1]++;
        } catch (Exception e) {
            System.out.println(e + ", i=" + i);
        }
    }
    static int val() throws Exception {
        throw new Exception("unimplemented");
    }
}

java.lang.Exception: unimplemented, i=99

float[][] matrix = new float[3][3];

float[][] matrix = new float[3][];
for (int d = 0; d < matrix.length; d++)
    matrix[d] = new float[3];

Age[][][][][] Aquarius = new Age[6][10][8][12][];

Age[][][][][] Aquarius = new Age[6][][][][];
for (int d1 = 0; d1 < Aquarius.length; d1++) {
    Aquarius[d1] = new Age[10][][][];
    for (int d2 = 0; d2 < Aquarius[d1].length; d2++) {
        Aquarius[d1][d2] = new Age[8][][];
        for (int d3 = 0; d3 < Aquarius[d1][d2].length; d3++) {
            Aquarius[d1][d2][d3] = new Age[12][];
        }
    }
}

Age[] Hair = { new Age("quartz"), new Age("topaz") };
Aquarius[1][9][6][9] = Hair;

float[][] triang = new float[100][];
for (int i = 0; i < triang.length; i++)
    triang[i] = new float[i+1];

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

class Test3 {
    public static void main(String[] args) {
        int len = 0, oldlen = 0;
        Object[] a = new Object[0];
        try {
            for (;;) {
                ++len;
                Object[] temp = new Object[oldlen = len];
                temp[0] = a;
                a = temp;
            }
        } catch (Error e) {
            System.out.println(e + ", " + (oldlen==len));
        }
    }
}

java.lang.OutOfMemoryError, true

Выражение доступа к элементу массива ссылается на переменную, являющуюся компонентом массива.

Выражение доступа к элементу массива содержит два подвыражения: выражение ссылки на массив (перед левой квадратной скобкой) и выражение индекса (в квадратных скобках).

Обратите внимание, что выражение ссылки на массив может быть именем или любым первичным выражением, которое не является выражением создания массива, если только выражение создания массива не имеет инициализатора массива (§15.10.1).

Тип выражения ссылки на массив должен быть типом массива (назовем его T[], массив, чьи компоненты имеют тип T), в противном случае произойдет ошибка компиляции.

Выражение индекса претерпевает числовое продвижение (§5.6). Продвинутый тип должен быть int, в противном случае произойдет ошибка компиляции.

Тип выражения доступа к элементу массива является результатом применения преобразования захвата (§5.1.10) к T.

Результат выражения доступа к элементу массива — это переменная типа T, а именно переменная внутри массива, выбранная значением выражения индекса.

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

Во время выполнения вычисление выражения доступа к элементу массива происходит следующим образом:

class Test1 {
    public static void main(String[] args) {
        int[] a = { 11, 12, 13, 14 };
        int[] b = { 0, 1, 2, 3 };
        System.out.println(a[(a=b)[3]]);
    }
}

14

class Test2 {
    public static void main(String[] args) {
        int index = 1;
        try {
            skedaddle()[index=2]++;
        } catch (Exception e) {
            System.out.println(e + ", index=" + index);
        }
    }
    static int[] skedaddle() throws Exception {
        throw new Exception("Ciao");
    }
}

java.lang.Exception: Ciao, index=1

class Test3 {
    public static void main(String[] args) {
        int index = 1;
        try {
            nada()[index=2]++;
        } catch (Exception e) {
            System.out.println(e + ", index=" + index);
        }
    }
    static int[] nada() { return null; }
}

java.lang.NullPointerException, index=2

class Test4 {
    public static void main(String[] args) {
        int[] a = null;
        try {
            int i = a[vamoose()];
            System.out.println(i);
        } catch (Exception e) {
            System.out.println(e);
        }
    }
    static int vamoose() throws Exception {
        throw new Exception("Twenty-three skidoo!");
    }
}

java.lang.Exception: Twenty-three skidoo!

Тип Primary должен быть типом ссылки T, в противном случае возникает ошибка компиляции.

Значение выражения доступа к полю определяется следующим образом:

Во время выполнения результат выражения доступа к полю вычисляется следующим образом: (предполагая, что программа верна с точки зрения анализа определенного присваивания, то есть каждая пустая final переменная определённо присваивается перед доступом)

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

class S           { int x = 0; }
class T extends S { int x = 1; }
class Test1 {
    public static void main(String[] args) {
        T t = new T();
        System.out.println("t.x=" + t.x + when("t", t));
        S s = new S();
        System.out.println("s.x=" + s.x + when("s", s));
        s = t;
        System.out.println("s.x=" + s.x + when("s", s));
    }
    static String when(String name, Object t) {
        return " when " + name + " holds a "
                        + t.getClass() + " at run time.";
    }
}

t.x=1 when t holds a class T at run time.
s.x=0 when s holds a class S at run time.
s.x=0 when s holds a class T at run time.

class S           { int x = 0; int z() { return x; } }
class T extends S { int x = 1; int z() { return x; } }
class Test2 {
    public static void main(String[] args) {
        T t = new T();
        System.out.println("t.z()=" + t.z() + when("t", t));
        S s = new S();
        System.out.println("s.z()=" + s.z() + when("s", s));
        s = t;
        System.out.println("s.z()=" + s.z() + when("s", s));
    }
    static String when(String name, Object t) {
        return " when " + name + " holds a "
                        + t.getClass() + " at run time.";
    }
}

t.z()=1 when t holds a class T at run time.
s.z()=0 when s holds a class S at run time.
s.z()=1 when s holds a class T at run time.

class Test3 {
    static String mountain = "Chocorua";
    static Test3 favorite(){
        System.out.print("Mount ");
        return null;
    }
    public static void main(String[] args) {
        System.out.println(favorite().mountain);
    }
}

Mount Chocorua

Форма super.Идентификатор относится к полю с именем Идентификатор текущего объекта, но с текущим объектом, рассматриваемым как экземпляр суперкласса текущего класса.

Форма T.super.Идентификатор относится к полю с именем Идентификатор лексически окружающего экземпляра, соответствующего T, но с этим экземпляром, рассматриваемым как экземпляр суперкласса T.

Формы, использующие ключевое слово super, могут использоваться в тех местах объявления класса, где разрешено ключевое слово this в качестве выражения (§15.8.3).

Ошибка компиляции, если выражение доступа к полю с ключевым словом super появляется в статическом контексте (§8.1.3).

Для выражения доступа к полю вида super.Идентификатор:

Для выражения доступа к полю вида T.super.Идентификатор:

Предположим, что выражение доступа к полю super.f появляется внутри класса C, и непосредственный суперкласс C — класс S. Если f в S доступен из класса C (§6.6), то super.f обрабатывается так, как если бы это было выражение this.f в теле класса S. В противном случае возникает ошибка компиляции.

Таким образом, super.f может получить доступ к полю f, которое доступно в классе S, даже если это поле скрыто объявлением поля f в классе C.

Предположим, что выражение доступа к полю T.super.f появляется внутри класса C, а непосредственный суперкласс класса, обозначенного T, — класс, полное имя которого S. Если f в S доступен из C, то T.super.f обрабатывается так, как если бы это было выражение this.f в теле класса S. В противном случае возникает ошибка компиляции.

Таким образом, T.super.f может получить доступ к полю f, которое доступно в классе S, даже если это поле скрыто объявлением поля f в классе T.

interface I           { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1   { int x = 2; }
class T3 extends T2 {
    int x = 3;
    void test() {
        System.out.println("x=\t\t"          + x);
        System.out.println("super.x=\t\t"    + super.x);
        System.out.println("((T2)this).x=\t" + ((T2)this).x);
        System.out.println("((T1)this).x=\t" + ((T1)this).x);
        System.out.println("((I)this).x=\t"  + ((I)this).x);
    }
}
class Test {
    public static void main(String[] args) {
        new T3().test();
    }
}

x=              3
super.x=        2
((T2)this).x=   2
((T1)this).x=   1
((I)this).x=    0

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

Имя метода задается ИменемМетода или Идентификатором, которые непосредственно предшествуют левой круглой скобке ВызоваМетода.

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

class Superclass {
    void foo() { System.out.println("Hi"); }
}

class Subclass1 extends Superclass {
    void foo() { throw new UnsupportedOperationException(); }

    Runnable tweak = new Runnable() {
        void run() {
            Subclass1.super.foo();  // Gets the 'println' behavior
        }
    };
}

interface Superinterface {
    default void foo() { System.out.println("Hi"); }
}

class Subclass2 implements Superinterface {
    void foo() { throw new UnsupportedOperationException(); }

    void tweak() {
        Superinterface.super.foo();  // Gets the 'println' behavior
    }
}

class Subclass3 implements Superinterface {
    void foo() { throw new UnsupportedOperationException(); }

    Runnable tweak = new Runnable() {
        void run() {
            Subclass3.Superinterface.super.foo();  // Illegal
        }
    };
}

Выражение ссылки на метод совместимо в контексте присваивания, контексте вызова или контексте приведения к типу T, если T является типом функционального интерфейса (§9.8) и выражение является совместимым с типом функции основного целевого типа, полученного из T.

Основной целевой тип выводится из T следующим образом:

Выражение ссылки на метод совместимо с типом функции, если оба следующих условия истинны:

Если для применения декларации во время компиляции потребовалось неявное преобразование, и это преобразование вызовет предупреждение во время компиляции в контексте вызова, то возникает предупреждение о неявном преобразовании во время компиляции, если оно не подавлено с помощью @SuppressWarnings (§9.6.4.5).

Если для совместимости типа возвращаемого значения R' с типом возвращаемого значения типа функции R, описанным выше, потребовалось неявное преобразование, и это преобразование вызовет предупреждение во время компиляции в контексте присваивания, то возникает предупреждение о неявном преобразовании во время компиляции, если оно не подавлено с помощью @SuppressWarnings.

Если выражение ссылки на метод совместимо с целевым типом T, то тип выражения U — это основной целевой тип, выведенный из T.

Возникает ошибка компиляции, если какой-либо класс или интерфейс, упомянутый либо в U, либо в типе функции U, недоступен (§6.6) из класса или интерфейса, в котором появляется выражение ссылки на метод.

Для каждого метода-члена U, который не является static членом, m, если тип функции U имеет подсигнатуру под сигнатурой m, то предполагаемый метод, тип метода которого — тип функции U, считается переопределяющим m, и может возникнуть любая ошибка компиляции или предупреждение, указанные в §8.4.8.3.

Для каждого типа исключения X, указанного в разделе throws типа вызова декларации во время компиляции, X или суперкласс X должен быть упомянут в разделе throws типа функции U, иначе возникнет ошибка компиляции.

Ключевая идея, лежащая в основе определения совместимости, заключается в том, что ссылка на метод совместима тогда и только тогда, когда эквивалентное лямбда-выражение (x, y, z) -> exp.<T1, T2>method(x, y, z) совместимо. (Это неформальное описание, и есть проблемы, которые затрудняют или делают невозможным формальное определение семантики в терминах такого переписывания.)

Эти правила совместимости обеспечивают удобный инструмент для преобразования из одного функционального интерфейса в другой:

Task t = () -> System.out.println("hi");
Runnable r = t::invoke;

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

В отличие от лямбда-выражения, ссылка на метод может быть совместима с обобщённым типом функции (то есть типом функции, имеющим параметры типа). Это связано с тем, что лямбда-выражение должно было бы уметь объявлять параметры типа, но синтаксис этого не поддерживает; в то время как для ссылки на метод такая декларация не требуется. Например, следующая программа является допустимой:

interface ListFactory {
    <T> List<T> make();
}

ListFactory lf  = ArrayList::new;
List<String> ls = lf.make();
List<Number> ln = lf.make();

Унарное выражение, предваряемое оператором ++, является выражением префиксного инкремента.

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

Тип выражения префиксного инкремента — это тип переменной. Результат выражения префиксного инкремента — это не переменная, а значение.

Во время выполнения, если вычисление выражения операнда завершается неожиданно, то выражение префиксного инкремента завершается по той же причине, и инкрементирование не происходит. В противном случае к значению переменной добавляется значение 1, и сумма сохраняется обратно в переменную. Перед сложением выполняется бинарное числовое продвижение (§5.6) для значения 1 и значения переменной. При необходимости сумма сужается с помощью сужающего преобразования примитивного типа (§5.1.3) и/или подвергается преобразованию упаковки (§5.1.7) до типа переменной перед сохранением. Значение выражения префиксного инкремента — это значение переменной после сохранения нового значения.

Обратите внимание, что бинарное числовое продвижение, упомянутое выше, может включать преобразование распаковки (§5.1.8).

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

Унарное выражение, предваряемое оператором --, является выражением префиксного декремента.

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

Тип выражения префиксного декремента — это тип переменной. Результат выражения префиксного декремента — это не переменная, а значение.

Во время выполнения, если вычисление выражения операнда завершается неожиданно, то выражение префиксного декремента завершается по той же причине, и декрементирование не происходит. В противном случае от значения переменной вычитается значение 1, и разность сохраняется обратно в переменную. Перед вычитанием выполняется бинарное числовое продвижение (§5.6) для значения 1 и значения переменной. При необходимости разность сужается с помощью сужающего преобразования примитивного типа (§5.1.3) и/или подвергается преобразованию упаковки (§5.1.7) до типа переменной перед сохранением. Значение выражения префиксного декремента — это значение переменной после сохранения нового значения.

Обратите внимание, что бинарное числовое продвижение, упомянутое выше, может включать преобразование распаковки (§5.1.8).

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

Тип операнда выражения унарного + оператора должен быть типом, преобразуемым (§5.1.8) к примитивному числовому типу, иначе произойдёт ошибка компиляции.

На операнде выполняется унарное числовое продвижение (§5.6). Тип выражения унарного плюса — это тип продвинутого операнда. Результат выражения унарного плюса не является переменной, а является значением, даже если результат выражения операнда является переменной.

Во время выполнения значение выражения унарного плюса — это продвинутое значение операнда.

Тип операнда выражения унарного - оператора должен быть типом, преобразуемым (§5.1.8) к примитивному числовому типу, иначе произойдёт ошибка компиляции.

На операнде выполняется унарное числовое продвижение (§5.6).

Тип выражения унарного минуса — это тип продвинутого операнда.

Во время выполнения значение выражения унарного минуса — это арифметическое отрицание продвинутого значения операнда.

Для целочисленных значений отрицание равно вычитанию из нуля. Язык программирования Java использует представление целых чисел в дополнительном коде, и диапазон значений в дополнительном коде несимметричен, поэтому отрицание максимального отрицательного int или long приводит к тому же максимальному отрицательному числу. В этом случае происходит переполнение, но исключение не генерируется. Для всех целочисленных значений x, -x равно (~x)+1.

Для значений с плавающей точкой отрицание не равно вычитанию из нуля, потому что если x равно +0.0, то 0.0-x равно +0.0, но -x равно -0.0. Унарный минус просто инвертирует знак числа с плавающей точкой. Важные особые случаи:

Тип операнда выражения унарного ~ оператора должен быть типом, преобразуемым (§5.1.8) к примитивному целочисленному типу, иначе произойдёт ошибка компиляции.

На операнде выполняется унарное числовое продвижение (§5.6). Тип выражения унарного побитового дополнения — это тип продвинутого операнда.

Во время выполнения значение выражения унарного побитового дополнения — это побитовое дополнение продвинутого значения операнда. Во всех случаях, ~x равно (-x)-1.

Тип операнда выражения унарного ! оператора должен быть типом boolean или Boolean, иначе произойдёт ошибка компиляции.

Тип выражения унарного логического дополнения — boolean.

Во время выполнения, если необходимо, операнд претерпевает преобразование разыменования (§5.1.8). Значение выражения унарного логического дополнения равно true, если значение операнда (возможно, преобразованное) равно false, и равно false, если значение операнда (возможно, преобразованное) равно true.

Двоичный оператор * выполняет умножение, получая произведение своих операндов.

Умножение является коммутативной операцией, если выражения операндов не имеют побочных эффектов.

Целочисленное умножение ассоциативно, когда все операнды имеют одинаковый тип.

Умножение с плавающей точкой не является ассоциативным.

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

Результат умножения с плавающей точкой определяется правилами арифметики IEEE 754:

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

Двоичный оператор / выполняет деление, получая частное от деления своих операндов. Левый операнд — это делимое, а правый операнд — делитель.

Целочисленное деление округляется к 0. То есть, частное, полученное для операндов n и d, являющихся целыми числами после двоичного числового продвижения (§5.6), — это целочисленное значение q, модуль которого как можно больше удовлетворяет условию |d ⋅ q| ≤ |n|. Более того, q положительно, когда |n| ≥ |d| и n и d имеют одинаковый знак, но q отрицательно, когда |n| ≥ |d| и n и d имеют разные знаки.

Есть один особый случай, который не удовлетворяет этому правилу: если делимое — это целое число с максимально возможным модулем для своего типа, а делитель — -1, то происходит переполнение, и результат равен делимому. Несмотря на переполнение, исключение в этом случае не выбрасывается. С другой стороны, если значение делителя в целочисленном делении равно 0, то выбрасывается ArithmeticException.

Результат деления с плавающей точкой определяется правилами арифметики IEEE 754:

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

Двоичный % оператор возвращает остаток от деления своих операндов; левый операнд — это делимое, а правый операнд — делитель.

В C и C++ оператор остатка принимает только целочисленные операнды, но в языке программирования Java он также принимает операнды с плавающей точкой.

Операция получения остатка для операндов, которые являются целыми числами после двоичного числового продвижения (§5.6), производит значение результата таким образом, что (a/b)*b+(a%b) равно a.

Это тождество выполняется даже в том специальном случае, когда делимое — это отрицательное целое число наибольшего возможного значения для его типа, а делитель — -1 (остаток — 0).

Из этого правила следует, что результат операции остатка может быть отрицательным только в том случае, если делимое отрицательное, и может быть положительным только в том случае, если делимое положительное. Кроме того, величина результата всегда меньше величины делителя.

Если значение делителя для целочисленного оператора остатка — 0, то выбрасывается ArithmeticException.

class Test1 {
    public static void main(String[] args) {
        int a = 5%3;  // 2
        int b = 5/3;  // 1
        System.out.println("5%3 produces " + a +
                           " (note that 5/3 produces " + b + ")");

        int c = 5%(-3);  // 2
        int d = 5/(-3);  // -1
        System.out.println("5%(-3) produces " + c +
                           " (note that 5/(-3) produces " + d + ")");

        int e = (-5)%3;  // -2
        int f = (-5)/3;  // -1
        System.out.println("(-5)%3 produces " + e +
                           " (note that (-5)/3 produces " + f + ")");

        int g = (-5)%(-3);  // -2
        int h = (-5)/(-3);  // 1
        System.out.println("(-5)%(-3) produces " + g +
                           " (note that (-5)/(-3) produces " + h + ")");
    }
}

5%3 produces 2 (note that 5/3 produces 1)
5%(-3) produces 2 (note that 5/(-3) produces -1)
(-5)%3 produces -2 (note that (-5)/3 produces -1)
(-5)%(-3) produces -2 (note that (-5)/(-3) produces 1)

Результат операции остатка с плавающей точкой, вычисленный оператором %, не такой же, как результат, вычисленный операцией остатка в IEEE 754, из-за выбора политики округления в языке программирования Java (§15.4). Операция остатка IEEE 754 вычисляет остаток от округления деления, а не от усечения, и поэтому ее поведение не аналогично поведению обычного целочисленного оператора остатка. Вместо этого язык программирования Java определяет % для операндов с плавающей точкой, чтобы он вел себя аналогично целочисленному оператору остатка с неявным делением с политикой округления к нулю; это можно сравнить с функцией библиотеки C fmod. Операцию остатка IEEE 754 можно вычислить с помощью библиотечной функции Math.IEEEremainder или StrictMath.IEEEremainder.

Результат операции остатка с плавающей точкой определяется следующими правилами, которые соответствуют арифметике IEEE 754, за исключением того, как вычисляется неявное деление:

Вычисление оператора остатка с плавающей точкой % никогда не вызывает исключения во время выполнения, даже если правый операнд равен нулю. Переполнение, недополнение или потеря точности не могут произойти.

class Test2 {
    public static void main(String[] args) {
        double a = 5.0%3.0;  // 2.0
        System.out.println("5.0%3.0 produces " + a);

        double b = 5.0%(-3.0);  // 2.0
        System.out.println("5.0%(-3.0) produces " + b);

        double c = (-5.0)%3.0;  // -2.0
        System.out.println("(-5.0)%3.0 produces " + c);

        double d = (-5.0)%(-3.0);  // -2.0
        System.out.println("(-5.0)%(-3.0) produces " + d);
    }
}

5.0%3.0 produces 2.0
5.0%(-3.0) produces 2.0
(-5.0)%3.0 produces -2.0
(-5.0)%(-3.0) produces -2.0

Тип каждого из операндов числового оператора сравнения должен быть типом, преобразуемым (§5.1.8) к примитивному числовому типу, в противном случае возникает ошибка компиляции.

На операндах выполняется двоичное числовое продвижение (§5.6).

Обратите внимание, что двоичное числовое продвижение может включать преобразование разупаковки (§5.1.8).

Если тип продвижения операндов — int или long, выполняется сравнение целых чисел со знаком.

Если тип продвижения — float или double, выполняется сравнение чисел с плавающей точкой.

Результат сравнения чисел с плавающей точкой, как определено спецификацией стандарта IEEE 754:

При соблюдении этих соображений для чисел с плавающей точкой, следующие правила применяются для целочисленных операндов или для операндов с плавающей точкой, отличных от NaN:

Выражение instanceof может выполнять сравнение типов или сопоставление с шаблоном.

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

Если операнд справа от ключевого слова instanceof является Шаблоном, то ключевое слово instanceof является оператором сопоставления с шаблоном.

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

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

class Point   { int x, y; }
class Element { int atomicNumber; }
class Test {
    public static void main(String[] args) {
        Point   p = new Point();
        Element e = new Element();
        if (e instanceof Point) {  // compile-time error
            System.out.println("I get your point!");
            p = (Point)e;  // compile-time error
        }
    }
}

class Point extends Element { int x, y; }

import java.util.ArrayList;
import java.util.List;

class Test2 {
    public static void main(String[] args) {
        List<Integer> x = new ArrayList<Integer>();

        if (x instanceof ArrayList<Integer>) {  // OK
            System.out.println("ArrayList of Integers");
        }
        if (x instanceof ArrayList<String>) {  // error
            System.out.println("ArrayList of Strings");
        }
        if (x instanceof ArrayList<Object>) {  // error
            System.out.println("ArrayList of Objects");
        }
    }
}