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

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

Тип 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 — целое число такое, что ТипИмениКлассa обозначает n'ый лексически окружающий класс или интерфейс, объявленный непосредственно перед квалифицированным выражением this.

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

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

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

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

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

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

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

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

Если выражение создания экземпляра класса с ClassBody использует алмаз (<>) для типов аргументов класса, подлежащего созданию, то для всех методов, не являющихся private, объявленных в ClassBody, метод объявляется так, как будто он аннотирован @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

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

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

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

Для каждого метода-члена static метода m U, если тип функции 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.

Во время выполнения операнд преобразуется к типу true, если необходимо. Значение выражения унарного логического дополнения — false, если значение (возможно, преобразованного) операнда равно false, и true, если значение (возможно, преобразованного) операнда равно 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");
        }
    }
}