Литерал (§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 обозначает значение, которое является ссылкой на объект, для которого был вызван метод экземпляра (§15.12), или на объект, который создается.

Тип this — это класс C, в котором встречается ключевое слово this.

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

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

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.

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

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

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

Если текущий класс не является вложенным классом класса C или самим классом C, это ошибка времени компиляции.

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

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

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

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

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

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

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

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

Если C — анонимный класс, то:

Если C — локальный класс (§14.3), то пусть O — самый внутренний лексически окружающий класс C. Пусть n — целое число такое, что O — n-й лексически окружающий класс класса, в котором появляется выражение создания экземпляра класса. Тогда:

В противном случае, C — внутренний член класса (§8.5), и тогда:

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

Если S — локальный класс (§14.3), то пусть O — самый внутренний лексически окружающий класс S. Пусть n — целое число такое, что O — n-й лексически окружающий класс класса, в котором появляется выражение создания экземпляра класса. Тогда:

В противном случае, S — внутренний член класса (§8.5), и тогда:

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

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

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

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

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

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

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

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

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

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

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

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

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.name появляется внутри класса C, а непосредственный предок C — класс S, то super.name обрабатывается точно так же, как если бы это было выражение this.name в теле класса S. Таким образом, он может получить доступ к полю name, видимому в классе S, даже если это поле скрыто объявлением поля name в классе C.

Если выражение доступа к полю T.super.name появляется внутри класса C, а непосредственный предок класса, обозначенного T, — это класс, полное имя которого S, то T.super.name обрабатывается точно так же, как если бы это было выражение this.name в теле класса S. Таким образом, он может получить доступ к полю name, видимому в классе S, даже если это поле скрыто объявлением поля name в классе 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

((T2)this).x

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

Если существует наиболее конкретное объявление метода для вызова метода, то оно называется объявлением во время компиляции для вызова метода.

Если вызов метода содержит, перед левой скобкой, ИмяМетода в форме Идентификатор, и объявление во время компиляции является методом-членом объекта, то:

Если вызов метода содержит, перед левой скобкой, ИмяМетода в форме ИмяТипа . Идентификатор, или если вызов метода, перед левой скобкой, имеет форму ИмяТипа . НеДикиеАргументыТипов Идентификатор, то объявление во время компиляции должно быть static, в противном случае возникает ошибка во время компиляции.

Причина в том, что вызов метода в этой форме не указывает ссылку на объект, который может служить в качестве this внутри метода-члена объекта.

Если вызов метода имеет, перед левой скобкой, форму super . НеДикиеАргументыТипов_опт Идентификатор, то:

Если вызов метода имеет, перед левой скобкой, форму ИмяКласса . super . НеДикиеАргументыТипов_опт Идентификатор, то:

Если объявление во время компиляции является void, то вызов метода должен быть выражением верхнего уровня (то есть, Выражение в операторе выражения (§14.8) или в части ForInit или ForUpdate оператора for (§14.14)), в противном случае возникает ошибка во время компиляции.

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

Метод является полиморфным по сигнатуре тогда и только тогда, когда выполняются все следующие условия:

В Java SE 7 единственными полиморфными по сигнатуре методами являются методы invoke и invokeExact класса java.lang.invoke.MethodHandle.

Если объявление во время компиляции для вызова метода не является полиморфным по сигнатуре, то типы его параметров — это типы формальных параметров, а тип результата — его выбранный тип результата.

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

Затем следующая информация во время компиляции связывается с вызовом метода для использования во время выполнения:

Если объявление во время компиляции для вызова метода не является void, то тип выражения вызова метода — это тип результата, указанный в объявлении во время компиляции.

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

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

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