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

Если все шаги выполняются как описано, без указания прерывистого завершения, оператор считается завершающимся нормально. Однако определенные события могут помешать оператору завершиться нормально:

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

Прерывистое завершение всегда имеет связанное причину, которая является одной из следующих:

Термины «завершение нормально» и «завершение прерывисто» также применяются к вычислению выражений (§15.6). Единственная причина, по которой выражение может завершиться прерывисто, — это сгенерированное исключение из-за либо оператора throw с заданным значением (§14.18), либо исключения времени выполнения или ошибки (§11 (Исключения), §15.6).

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

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

Если не указано иное, оператор завершается нормально, если все вычисляемые им выражения и все выполняемые им подоператоры завершаются нормально.

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

Блок выполняется путем последовательного выполнения операторов объявления локальных переменных и других операторов в порядке следования (слева направо). Если все эти операторы блока завершаются нормально, то и блок завершается нормально. Если любой из этих операторов блока завершается неожиданно по какой-либо причине, то и весь блок завершается неожиданно по той же причине.

Локальный класс — это вложенный класс (§8 (Классы)), который не является членом какого-либо класса и имеет имя (§6.2, §6.7).

Все локальные классы являются внутренними классами (§8.1.3).

Каждое объявление локального класса непосредственно содержится в блоке (§14.2). Объявления локальных классов могут свободно перемешиваться с другими видами операторов в блоке.

Если объявление локального класса содержит какие-либо модификаторы доступа public, protected или private (§6.6), или модификатор static (§8.1.1), то это является ошибкой компиляции.

Область действия и затенение объявления локального класса определяются в §6.3 и §6.4.

class Global {
    class Cyclic {}

    void foo() {
        new Cyclic(); // create a Global.Cyclic
        class Cyclic extends Cyclic {} // circular definition

        {
            class Local {}
            {
                class Local {} // compile-time error
            }
            class Local {} // compile-time error
            class AnotherLocal {
                void bar() {
                    class Local {} // ok
                }
            }
        }
        class Local {} // ok, not in scope of prior Local
    }
}

В языке программирования Java существует множество типов операторов. Большинство из них соответствуют операторам языков C и C++, но некоторые являются уникальными.

Как и в C и C++, оператор if языка программирования Java страдает от так называемой проблемы «висящего else», иллюстрируемой этим вводящим в заблуждение примером:

if (door.isOpen())
    if (resident.isVisible())
        resident.greet("Hello!");
else door.bell.ring();  // A "dangling else"

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

Язык программирования Java, как и C, C++ и многие языки программирования до них, произвольно определяет, что предложение else относится к самому внутреннему оператору if, к которому оно может потенциально относиться. Это правило отображается в следующей грамматике:

Следующие определения из §14.9 приведены здесь для удобства:

Операторы таким образом грамматически делятся на две категории: те, которые могут заканчиваться оператором if, у которого нет предложения else (оператор «короткий if») и те, которые определённо не заканчиваются им.

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

Это простое правило предотвращает проблему «висящего else». Поведение оператора с ограничением «без короткого if» идентично поведению оператора такого же типа без ограничения «без короткого if»; различие введено исключительно для решения синтаксической трудности.

Пустой оператор ничего не делает.

Выполнение пустого оператора всегда завершается успешно.

Операторы могут иметь префиксы меток.

Идентификатор объявляется меткой непосредственно содержащегося оператора.

В отличие от C и C++, язык программирования Java не имеет оператора goto; метки операторов-идентификаторов используются с операторами break или continue (раздел §14.15, раздел §14.16) встречающимися где угодно внутри меткированного оператора.

Областью действия метки помеченного оператора является непосредственно содержащийся оператор.

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

Нет ограничений на использование одного и того же идентификатора в качестве метки и в качестве имени пакета, класса, интерфейса, метода, поля, параметра или локальной переменной. Использование идентификатора для маркировки оператора не скрывает (§6.4.2) пакет, класс, интерфейс, метод, поле, параметр или локальную переменную с тем же именем. Использование идентификатора в качестве класса, интерфейса, метода, поля, локальной переменной или в качестве параметра обработчика исключений (§14.20) не скрывает метку оператора с тем же именем.

Меткированный оператор выполняется путем выполнения непосредственно содержащегося оператора.

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

class Test {
    char[] value;
    int offset, count;
    int indexOf(TestString str, int fromIndex) {
        char[] v1 = value, v2 = str.value;
        int max = offset + (count - str.count);
        int start = offset + ((fromIndex < 0) ? 0 : fromIndex);
    i:
        for (int i = start; i <= max; i++) {
            int n = str.count, j = i, k = str.offset;
            while (n-- != 0) {
                if (v1[j++] != v2[k++])
                    continue i;
            } 
            return i - offset;
        }
        return -1;
    }
}

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

Оператор выражения выполняется путем оценки выражения; если выражение имеет значение, это значение отбрасывается.

Выполнение оператора выражения завершается нормально, если и только если оценка выражения завершается нормально.

В отличие от C и C++, язык программирования Java позволяет использовать только определенные формы выражений в качестве операторов выражения. Например, разрешается использовать выражение вызова метода (§15.12):

System.out.println("Hello world");  // OK

но не разрешается использовать выражение в скобках (§15.8.5):

(System.out.println("Hello world"));  // illegal

Обратите внимание, что язык программирования Java не допускает «приведения к типу void» — void не является типом — поэтому традиционный трюк C с оператором выражения, например:

(void)... ;  // incorrect!

не работает. С другой стороны, язык программирования Java позволяет использовать все наиболее полезные виды выражений в операторах выражений и не требует, чтобы вызов метода, используемого как оператор выражения, вызывал метод void, поэтому такой трюк почти никогда не нужен. Если требуется трюк, вместо него можно использовать оператор присваивания (§15.26) или оператор объявления локальной переменной (§14.4).

Оператор if позволяет условно выполнить оператор или выбрать один из двух операторов, выполняя один из них, но не оба.

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

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

Для упрощения изложения, первое выражение в обоих формах оператора assert называется выражение1. Во второй форме оператора assert второе выражение называется выражение2.

Если выражение1 не имеет тип boolean или Boolean, возникает ошибка компиляции.

Если во второй форме оператора assert выражение2 является void (§15.1), возникает ошибка компиляции.

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

Определение того, разрешает ли верхний уровень класса или интерфейса утверждения, происходит не позднее чем (i) инициализация верхнего уровня класса или интерфейса, и (ii) инициализация любого класса или интерфейса, вложенного в верхний уровень класса или интерфейса. После определения, разрешение утверждений верхним уровнем класса или интерфейса изменить нельзя.

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

public class Foo {
    public static void main(String[] args) {
        Baz.testAsserts(); 
        // Will execute after Baz is initialized.
    }
}
class Bar {
    static {
        Baz.testAsserts(); 
        // Will execute before Baz is initialized!
    }
}
class Baz extends Bar {
    static void testAsserts() {
        boolean enabled = false;
        assert  enabled = true;
        System.out.println("Asserts " + 
			   (enabled ? "enabled" : "disabled"));
    }
}

Asserts enabled
Asserts disabled

Выключенное утверждение assert ничего не делает. В частности, ни выражение1, ни выражение2 (если оно присутствует) не вычисляются. Выполнение выключенного утверждения assert всегда завершается нормально.

Активное утверждение assert выполняется путём сначала вычисления выражение1. Если результат имеет тип Boolean, он подвергается преобразованию распаковки (§5.1.8).

Если вычисление выражение1 или последующее преобразование распаковки (если таковое имеется) завершается аномально по какой-либо причине, утверждение assert завершается аномально по той же причине.

В противном случае выполнение продолжается, принимая решение на основе значения выражение1:

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

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

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

Дополнительная проблема с использованием утверждений для проверки аргументов заключается в том, что ошибочные аргументы должны приводить к соответствующему исключению во время выполнения (такому как IllegalArgumentException, ArrayIndexOutOfBoundsException или NullPointerException). Ошибка утверждения не вызовет соответствующее исключение. Опять же, не является ошибкой использование утверждений для проверки аргументов в методах public, но это, как правило, не рекомендуется. Предполагается, что AssertionError никогда не будет перехвачен, но это возможно, поэтому правила для операторов try должны обрабатывать утверждения, появляющиеся в блоке try, аналогично текущей обработке операторов throw.

Оператор switch передает управление одному из нескольких операторов в зависимости от значения выражения.

Тип Выражения должен быть char, byte, short, int, Character, Byte, Short, Integer, String или типом перечисления (§8.9), иначе произойдёт ошибка компиляции.

Тело оператора switch называется блоком switch. Любой оператор, непосредственно содержащийся в блоке switch, может быть помечен одной или несколькими метками switch, которые являются case или default метками. У каждой case метки есть case константа, которая является либо константным выражением, либо именем константы перечисления. Метки switch и их case константы называются ассоциированными с оператором switch.

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

Запрет использования null в качестве case константы предотвращает создание кода, который никогда не будет выполняться. Если Выражение оператора switch относится к ссылочному типу, то есть String, упакованному примитивному типу или типу перечисления, то будет брошено исключение, если Выражение при выполнении приведёт к значению null. По мнению разработчиков языка Java, это лучше, чем пропустить весь оператор switch или выбрать выполнение операторов (если есть) после метки default (если есть).

Компилятор Java рекомендуется (но не обязан) выдавать предупреждение, если в операторе switch с выражением типа перечисления отсутствует метка default и отсутствуют case метки для одной или нескольких констант перечисления. Такой оператор ничего не сделает, если выражение приведёт к одному из пропущенных значений.

for (i = 0; i < n; ++i) foo();

int q = (n+7)/8;
switch (n%8) {
    case 0: do { foo();    // Great C hack, Tom,
    case 7:      foo();    // but it's not valid here.
    case 6:      foo();
    case 5:      foo();
    case 4:      foo();
    case 3:      foo();
    case 2:      foo();
    case 1:      foo();
            } while (--q > 0);
}

Оператор switch выполняется путём сначала вычисления Выражения. Если Выражение вычислится к null, будет брошено NullPointerException, и весь оператор switch завершится преждевременно по этой причине. В противном случае, если результат имеет тип Character, Byte, Short или Integer, он подвергается распаковке (§5.1.8).

Если вычисление Выражения или последующая распаковка (если применимо) завершаются преждевременно по какой-либо причине, оператор switch завершается преждевременно по той же причине.

В противном случае выполнение продолжается путём сравнения значения Выражения с каждой case константой, и есть выбор:

Если любой оператор, непосредственно содержащийся в теле блока Block оператора switch, завершается преждевременно, то это обрабатывается следующим образом:

class TooMany {
    static void howMany(int k) {
        switch (k) {
            case 1: System.out.print("one ");
            case 2: System.out.print("too ");
            case 3: System.out.println("many");
        }
    }
    public static void main(String[] args) {
        howMany(3);
        howMany(2);
        howMany(1);
    }
}

many
too many
one too many

class TwoMany {
    static void howMany(int k) {
        switch (k) {
            case 1: System.out.println("one");
                    break;  // exit the switch
            case 2: System.out.println("two");
                    break;  // exit the switch
            case 3: System.out.println("many");
                    break;  // not needed, but good style
        }
    }
    public static void main(String[] args) {
        howMany(1);
        howMany(2);
        howMany(3);
    }
}

one
two
many

Оператор цикла while выполняет Выражение и Оператор многократно, пока значение Выражения не будет false.

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

Оператор цикла while выполняется следующим образом: сначала вычисляется Выражение. Если результат имеет тип Boolean, он подвергается приведению к типу значения (§5.1.8).

Если вычисление Выражения или последующее приведение к типу значения (если таковое имеется) завершается прерыванием по какой-либо причине, оператор while также завершается прерыванием по той же причине.

В противном случае выполнение продолжается, принимая решение на основе полученного значения:

Оператор do выполняет Оператор и Выражение повторно до тех пор, пока значение Выражения не будет false.

Выражение должно иметь тип boolean или Boolean, иначе произойдёт ошибка компиляции.

Оператор do выполняется путём сначала выполнения Оператора. Затем следует выбор:

Выполнение оператора do всегда выполняет содержащийся Оператор хотя бы один раз.

public static String toHexString(int i) {
    StringBuffer buf = new StringBuffer(8);
    do {
        buf.append(Character.forDigit(i & 0xF, 16));
        i >>>= 4;
    } while (i != 0);
    return buf.reverse().toString();
}

Оператор break передает управление из вложенного оператора.

Оператор break без метки пытается передать управление самому внутреннему вложенному оператору switch, while, do или for в непосредственно окружающем методе или инициализаторе; этот оператор, который называется целью оператора break, затем немедленно завершается нормально.

Точнее, оператор break без метки всегда завершается прерывисто, по причине оператора break без метки.

Если ни один оператор switch, while, do или for в непосредственно окружающем методе, конструкторе или инициализаторе не содержит оператор break, возникает ошибка компиляции.

Оператор break с меткой Identifier пытается передать управление вложенному оператору с меткой (§14.7), который имеет ту же метку Identifier; этот оператор, который называется целью оператора break, затем немедленно завершается нормально. В этом случае цель оператора break не обязательно должна быть оператором switch, while, do или for.

Точнее, оператор break с меткой Identifier всегда завершается прерывисто, по причине оператора break с меткой Identifier.

Оператор break должен ссылаться на метку внутри непосредственно окружающего метода, конструктора, инициализатора или блока лямбда-выражения. Не существует нелокальных переходов. Если ни один оператор с меткой Identifier в непосредственно окружающем методе, конструкторе, инициализаторе или блоке лямбда-выражения не содержит оператор break, возникает ошибка компиляции.

Из этого следует, что оператор break всегда завершается прерывисто.

В предыдущих описаниях используется фраза «пытается передать управление», а не просто «передает управление», потому что если внутри цели оператора break есть любые операторы try (§14.20), блоки try или разделы catch которых содержат оператор break, то любые разделы finally этих операторов try выполняются в порядке, от самого внутреннего к самому внешнему, прежде чем управление передается цели оператора break. Прерывистое завершение раздела finally может нарушить передачу управления, начатую оператором break.

class Graph {
    int edges[][];
    public Graph(int[][] edges) { this.edges = edges; }

    public Graph loseEdges(int i, int j) {
        int n = edges.length;
        int[][] newedges = new int[n][];
        for (int k = 0; k < n; ++k) {
edgelist:
{
            int z;
search:
{
            if (k == i) {
                for (z = 0; z < edges[k].length; ++z) {
                    if (edges[k][z] == j) break search;
                }
            } else if (k == j) {
                for (z = 0; z < edges[k].length; ++z) {
                    if (edges[k][z] == i) break search;
                }
            }

            // No edge to be deleted; share this list.
            newedges[k] = edges[k];
            break edgelist;
} //search

            // Copy the list, omitting the edge at position z.
            int m = edges[k].length - 1;
            int ne[] = new int[m];
            System.arraycopy(edges[k], 0, ne, 0, z);
            System.arraycopy(edges[k], z+1, ne, z, m-z);
            newedges[k] = ne;
} //edgelist
        }
        return new Graph(newedges);
    }
}

Оператор continue может встречаться только в операторе while, do или for; операторы этих трёх типов называются операторными циклами. Управление передается точке продолжения цикла операторного цикла.

Оператор continue без метки пытается передать управление самому внутреннему вложенному оператору while, do или for в непосредственно окружающем методе, конструкторе или инициализаторе; этот оператор, который называется целью оператора continue, затем немедленно завершает текущую итерацию и начинает новую.

Точнее, такой оператор continue всегда завершается прерывисто, по причине оператора continue без метки.

Если ни один оператор while, do или for в непосредственно окружающем методе, конструкторе или инициализаторе не содержит оператор continue, возникает ошибка компиляции.

Оператор continue с меткой Identifier пытается передать управление вложенному оператору с меткой (§14.7), который имеет ту же метку Identifier; этот оператор, который называется целью оператора continue, затем немедленно завершает текущую итерацию и начинает новую.

Точнее, оператор continue с меткой Identifier всегда завершается прерывисто, по причине оператора continue с меткой Identifier.

Цель оператора continue должна быть оператором while, do или for, в противном случае возникает ошибка компиляции.

Оператор continue должен ссылаться на метку внутри непосредственно окружающего метода, конструктора, инициализатора или блока лямбда-выражения. Не существует нелокальных переходов. Если ни один оператор с меткой Identifier в непосредственно окружающем методе, конструкторе, инициализаторе или блоке лямбда-выражения не содержит оператор continue, возникает ошибка компиляции.

Из этого следует, что оператор continue всегда завершается прерывисто.

См. описания оператора while (§14.12), оператора do (§14.13) и оператора for (§14.14) для обсуждения обработки прерывистого завершения из-за оператора continue.

В предыдущих описаниях используется фраза «пытается передать управление», а не просто «передает управление», потому что если внутри цели оператора continue есть любые операторы try (§14.20), блоки try или разделы catch которых содержат оператор continue, то любые разделы finally этих операторов try выполняются в порядке, от самого внутреннего к самому внешнему, прежде чем управление передается цели оператора continue. Прерывистое завершение раздела finally может нарушить передачу управления, начатую оператором continue.

class Graph {
    int edges[][];
    public Graph(int[][] edges) { this.edges = edges; }

    public Graph loseEdges(int i, int j) {
        int n = edges.length;
        int[][] newedges = new int[n][];
edgelists:
        for (int k = 0; k < n; ++k) {
            int z;
search:
{
            if (k == i) {
                for (z = 0; z < edges[k].length; ++z) {
                    if (edges[k][z] == j) break search;
                }
            } else if (k == j) {
                for (z = 0; z < edges[k].length; ++z) {
                    if (edges[k][z] == i) break search;
                }
            }

            // No edge to be deleted; share this list.
            newedges[k] = edges[k];
            continue edgelists;
} //search

            // Copy the list, omitting the edge at position z.
            int m = edges[k].length - 1;
            int ne[] = new int[m];
            System.arraycopy(edges[k], 0, ne, 0, z);
            System.arraycopy(edges[k], z+1, ne, z, m-z);
            newedges[k] = ne;
        } //edgelists
        return new Graph(newedges);
    }
}

Оператор return возвращает управление вызывающей стороне метода (§8.4), конструктора (§8.8) или лямбда-выражения (§15.12, §15.9, §15.27).

Оператор return вложен внутри самого внутреннего конструктора, метода, инициализатора или лямбда-выражения, тело которого содержит этот оператор.

Если оператор return находится внутри инициализатора экземпляра или статического инициализатора (§8.6, §8.7), возникает ошибка компиляции.

Оператор return без Выражения должен находиться в одном из следующих контекстов, иначе возникает ошибка компиляции:

Оператор return без Выражения пытается передать управление вызывающей стороне метода, конструктора или лямбда-выражения, содержащего этот оператор. Точнее, оператор return без Выражения всегда завершается внезапно, по причине возврата без значения.

Оператор return с Выражением должен находиться в одном из следующих контекстов, иначе возникает ошибка компиляции:

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

Если оператор return с Выражением находится в методе, то Выражение должно быть присваиваемым (§5.2) типу возвращаемого значения этого метода, иначе возникает ошибка компиляции.

Оператор return с Выражением пытается передать управление вызывающей стороне метода или лямбда-выражения, содержащего оператор; значение Выражения становится значением результата вызова метода. Точнее, выполнение оператора return с Выражением сначала оценивает Выражение. Если оценка Выражения завершается внезапно по какой-либо причине, то оператор return также завершается внезапно по той же причине. Если оценка Выражения завершается нормально, произведя значение V, то оператор return завершается внезапно, по причине возврата со значением V.

Если выражение имеет тип float и не является FP-строгим (§15.4), то значение может быть элементом либо набора значений типа float, либо расширенного набора значений с плавающей точкой (§4.2.3). Если выражение имеет тип double и не является FP-строгим, то значение может быть элементом либо набора значений типа double, либо расширенного набора значений с плавающей точкой.

Таким образом, оператор return всегда завершается внезапно.

В описаниях используется фраза «пытается передать управление», а не просто «передает управление», потому что если есть операторы try (§14.20) внутри метода или конструктора, блоки try или catch которых содержат оператор return, то любые finally блоки этих операторов будут выполнены в порядке от внутреннего к внешнему, прежде чем управление будет передано вызывающей стороне метода или конструктора. Внезапное завершение блока finally может нарушить передачу управления, инициированную оператором return.

Оператор throw вызывает исключение (§11 (Исключения)) для выбрасывания. Результатом является непосредственная передача управления (§11.3), которая может выйти из нескольких операторов и нескольких инициализаций конструкторов, инициализаций экземпляров, статических инициализаций и инициализаций полей, а также вызовов методов до тех пор, пока не будет найден оператор try (§14.20), который перехватывает значение, сгенерированное оператором `throw`. Если такой оператор try не найден, то выполнение потока (§17 (Потоки и блокировки)), который выполнил оператор throw, завершается (§11.3) после вызова метода uncaughtException для группы потоков, к которой принадлежит поток.

Выражение Выражение в операторе throw должно либо обозначать переменную или значение ссылочного типа, которое можно присвоить (§5.2) типу Throwable, или обозначать нулевую ссылку, в противном случае возникает ошибка компиляции.

Ссылочный тип Выражение всегда будет типом класса (так как типы интерфейсов не могут быть присвоены типу Throwable), который не является параметризованным (поскольку подкласс Throwable не может быть обобщённым (§8.1.2)).

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

Типы исключений, которые может сгенерировать оператор throw, указаны в §11.2.2.

Оператор throw сначала вычисляет Выражение. Затем:

Таким образом, оператор throw всегда завершается прерывисто.

Если есть какие-либо окружающие операторы try (§14.20), блоки try которых содержат оператор throw, то любые блоки finally этих операторов try выполняются по мере передачи управления наружу, пока выброшенное значение не будет перехвачено. Обратите внимание, что прерывистое завершение блока finally может нарушить передачу управления, начатую оператором throw.

Если оператор throw находится внутри объявления метода или лямбда-выражения, но его значение не перехвачено каким-либо оператором try, который его содержит, то вызов метода завершается прерывисто из-за throw.

Если оператор throw находится внутри объявления конструктора, но его значение не перехвачено каким-либо оператором try, который его содержит, то выражение создания экземпляра класса, которое вызвало конструктор, завершится прерывисто из-за throw (§15.9.4).

Если оператор throw содержится в статической инициализации (§8.7), то проверка времени компиляции (§11.2.3) гарантирует, что его значение всегда является необрабатываемым исключением или что его значение всегда перехватывается каким-либо оператором try, который его содержит. Если во время выполнения, несмотря на эту проверку, значение не перехватывается каким-либо оператором try, который содержит оператор throw, то значение повторно выбрасывается, если оно является экземпляром класса Error или одного из его подклассов; в противном случае оно упаковывается в объект ExceptionInInitializerError, который затем выбрасывается (§12.4.2).

Если оператор throw находится внутри инициализации экземпляра (§8.6), то проверка времени компиляции (§11.2.3) гарантирует, что его значение всегда является необрабатываемым исключением или что его значение всегда перехватывается каким-либо оператором try, который его содержит, или тип выброшенного исключения (или один из его суперклассов) присутствует в фразе throws каждого конструктора класса.

По соглашению, пользовательские типы исключений обычно объявляются подклассами класса Exception, который является подклассом класса Throwable (§11.1.1).

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

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

Оператор synchronized выполняется путём сначала оценки Выражение. Затем:

Блокировки, приобретаемые операторами synchronized, такие же, как блокировки, которые неявно приобретаются синхронизированными методами (§8.4.3.6). Одна нить может приобретать блокировку более одного раза.

Приобретение блокировки, связанной с объектом, само по себе не препятствует другим нитям обращаться к полям объекта или вызывать не-синхронизированные методы объекта. Другие нити также могут использовать синхронизированные методы или оператор synchronized стандартным способом для достижения взаимного исключения.

class Test {
    public static void main(String[] args) {
        Test t = new Test();
        synchronized(t) {
            synchronized(t) {
                System.out.println("made it!");
            }
        }
    }
}

made it!