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

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

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

Infinity
1.6e+308

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

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

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

Тип this — тип класса или интерфейса T, в котором встречается ключевое слово this.

Методы по умолчанию предоставляют уникальную возможность доступа к this внутри интерфейса. (Все остальные методы интерфейса являются либо abstract, либо static, поэтому не обеспечивают доступа к this). В результате, this может иметь тип интерфейса.

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

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.

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

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

Тип выражения — T.

Ошибка компиляции, если выражение встречается в классе или интерфейсе, который не является вложенным классом класса T или T сам.

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

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

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

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

Если выражение в скобках встречается в контексте определённого типа с целевым типом 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) и подробно описан в §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

Объявление анонимного класса автоматически генерируется компилятором Java из выражения создания экземпляра класса.

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

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

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

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

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

Если выражение создания экземпляра класса использует <> с анонимным классом, то для всех методов, не являющихся 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.1). Продвинутый тип должен быть 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.1). Продвинутый тип должен быть 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 появляются в объявлении класса Object, так как у Object нет суперкласса.

Предположим, что выражение доступа к полю 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.

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

Для каждого типа исключения X в списке throws в типе вызова объявления во время компиляции, 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.2) над значением 1 и значением переменной. При необходимости сумма сужается с помощью сужающего преобразования примитивного типа (§5.1.3) и/или подвергается преобразованию упаковки (§5.1.7) в тип переменной перед сохранением. Значение выражения префиксного инкремента - это значение переменной после сохранения нового значения.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Результат дробного деления определяется правилами арифметики IEEE 754:

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

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

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

Операция остатка для операндов, которые являются целыми числами после бинарного числового повышения (§5.6.2), производит значение результата, такое что (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. Операция остатка IEEE 754 вычисляет остаток от округленного деления, а не от усеченного деления, и поэтому ее поведение не аналогично поведению обычного оператора остатка целых чисел. Вместо этого, язык программирования Java определяет % для операций с плавающей запятой таким образом, чтобы поведение соответствовало поведению оператора остатка целых чисел; это можно сравнить с функцией C-библиотеки fmod. Операция остатка IEEE 754 может быть вычислена процедурой библиотеки Math.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

Если только один операнд-выражение имеет тип String, то преобразование к строке (§5.1.11) выполняется для другого операнда, чтобы создать строку во время выполнения.

Результат конкатенации строк — ссылка на объект String, который представляет собой конкатенацию двух строковых операндов. Символы левого операнда предшествуют символам правого операнда в новой созданной строке.

Объект String создаётся заново (§12.5), если выражение не является константным выражением (§15.28).

Реализация может выбрать выполнение преобразования и конкатенации в одном шаге, чтобы избежать создания и последующего удаления промежуточного объекта String. Для повышения производительности при многократной конкатенации строк, компилятор Java может использовать класс StringBuffer или подобную технику для сокращения количества промежуточных объектов String, создаваемых при вычислении выражения.

Для примитивных типов реализация также может оптимизировать создание обёртки, преобразуя примитивный тип непосредственно в строку.

"The square root of 2 is " + Math.sqrt(2)

"The square root of 2 is 1.4142135623730952"

a + b + c

(a + b) + c

1 + 2 + " fiddlers"

"3 fiddlers"

"fiddlers " + 1 + 2

"fiddlers 12"

class Bottles {
    static void printSong(Object stuff, int n) {
        String plural = (n == 1) ? "" : "s";
  loop: while (true) {
            System.out.println(n + " bottle" + plural
                    + " of " + stuff + " on the wall,");
            System.out.println(n + " bottle" + plural
                    + " of " + stuff + ";");
            System.out.println("You take one down "
                    + "and pass it around:");
            --n;
            plural = (n == 1) ? "" : "s";
            if (n == 0)
                break loop;
            System.out.println(n + " bottle" + plural
                    + " of " + stuff + " on the wall!");
            System.out.println();
        }
        System.out.println("No bottles of " +
                    stuff + " on the wall!");
    }

    public static void main(String[] args) {
        printSong("slime", 3);
    }
}

3 bottles of slime on the wall,
3 bottles of slime;
You take one down and pass it around:
2 bottles of slime on the wall!

2 bottles of slime on the wall,
2 bottles of slime;
You take one down and pass it around:
1 bottle of slime on the wall!

1 bottle of slime on the wall,
1 bottle of slime;
You take one down and pass it around:
No bottles of slime on the wall!

"You take one down and pass it around:"

Бинарный оператор + выполняет сложение, когда применяется к двум операндам числового типа, производя сумму операндов.

Бинарный оператор - выполняет вычитание, производя разность двух числовых операндов.

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

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

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

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

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

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

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

Сложение с плавающей запятой не является ассоциативным.

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

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

Бинарный оператор - выполняет вычитание, когда применяется к двум операндам числового типа, производя разность операндов; левый операнд — уменьшаемое, а правый операнд — вычитаемое.

Как для целочисленного, так и для вычитания с плавающей запятой, всегда верно, что a-b даёт тот же результат, что и a+(-b).

Обратите внимание, что для целочисленных значений вычитание из нуля то же самое, что и отрицание. Однако для операндов с плавающей запятой вычитание из нуля не то же самое, что отрицание, так как если x — +0.0, то 0.0-x это +0.0, но -x — -0.0.

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