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

Если оператор является оператором сложного присваивания (§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.

Тип 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>.

Ошибка компиляции, если именованный тип — это переменная типа (§4.4) или параметризованный тип (§4.5), или массив, тип элемента которого — переменная или параметризованный тип.

Ошибка компиляции, если именованный тип не обозначает доступный (§6.6) и находящийся в области видимости (§6.3) тип в точке появления литерала класса.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Сначала определяются фактические аргументы вызова конструктора:

Во-вторых, определяется конструктор C и соответствующий тип возвращаемого значения и throws фрагмент:

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

Если объявление во время компиляции применимо по вызову с переменным числом аргументов (§15.12.2.4), то, где последний тип формального параметра типа вызова конструктора — F_n[], ошибка компиляции возникает, если тип, являющийся стиранием F_n, недоступен в момент вызова.

Тип выражения создания экземпляра класса — это тип возврата выбранного конструктора, как определено выше.

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

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

Во-первых, если выражение создания экземпляра класса является квалифицированным выражением создания экземпляра класса, то квалифицируемое основное выражение вычисляется. Если квалифицирующее выражение вычисляет значение 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).

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

Выражение создания массива используется для создания новых массивов (§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 следующим образом:

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

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

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

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

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

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

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