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

Литерал класса вычисляет объект Class для указанного класса, интерфейса, типа массива или примитивного типа (или для 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 использует алмаз (<>) для параметров типа анонимного класса, который должен быть создан, то для всех не-private методов, объявленных в ClassBody, метод объявляется как будто помеченный @Override (§9.6.4.4).

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

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

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

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

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

Тип выражения ссылки на массив должен быть типом массива (назовём его 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

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

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

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

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

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

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

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

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

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

Переменную, объявленную final, нельзя декрементировать, потому что при использовании доступа к такой 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");
        }
    }
}