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

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

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

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

Термины «завершиться нормально» и «завершиться прерывисто» также применяются к вычислению выражений (§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
    }
}

Объявление локальной переменной — это оператор, объявляющий одно или несколько имён локальных переменных.

Следующее повторяется из §8.4.1 и §8.3, чтобы сделать изложение здесь более ясным:

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

Объявление локальной переменной также может появиться в заголовке оператора for (§14.14). В этом случае оно выполняется так же, как если бы оно было частью оператора объявления локальной переменной.

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

Таким образом, управляющие инструкции грамматически делятся на две категории: те, которые могут заканчиваться инструкцией без клаузы else ("короткая инструкция if"), и те, которые определенно не могут.

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

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

Пустая инструкция ничего не делает.

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

Инструкции могут иметь префиксы метки.

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

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

Область действия метки инструкции с меткой — непосредственно содержащаяся Управляющая инструкция.

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

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

Инструкция с меткой выполняется путём выполнения непосредственно содержащейся Управляющей инструкции.

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

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

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

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

В отличие от C и C++, язык программирования Java позволяет использовать только определенные формы выражений в качестве инструкций выражения. Обратите внимание, что язык программирования Java не допускает "приведения к void" - void не является типом - поэтому традиционный трюк C с написанием инструкции выражения, например:

(void)... ;  // incorrect!

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

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

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

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

Ошибка компиляции возникает, если Expression1 не имеет тип boolean или Boolean.

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

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

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

Оператор 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 не выполняет никаких действий. В частности, ни Expression1, ни Expression2 (если оно присутствует) не оцениваются. Выполнение деактивированного оператора assert всегда завершается нормально.

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

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

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

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

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

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

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

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

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

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

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

Тело оператора switch называется блоком switch.

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

Эти метки считаются связанными с оператором switch, а также со значениями константных выражений (§15.28) или констант перечислений (§8.9.1) в метках case.

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

Запрет на использование null в качестве метки switch предотвращает написание кода, который никогда не будет выполнен. Если 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 завершается прерыванием по этой причине. В противном случае, если результат является ссылочного типа, он подвергается преобразованию распаковки (§5.1.8).

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

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

Если любой оператор, непосредственно вложенный в Блок тела оператора 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 без метки пытается передать управление самому внутреннему окружающему оператору цикла for, while, do-while или оператору switch в немедленно окружающем методе или инициализаторе; этот оператор, который называется целью break, затем завершается нормально.

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

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

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

Точнее, оператор break с меткой Идентификатор всегда завершается неожиданно, причиной чего является оператор break с меткой Идентификатор.

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

Можно видеть, что оператор break всегда завершается неожиданно.

Предыдущие описания говорят "пытается передать управление", а не просто "передает управление", потому что если в цели break есть операторы try (§14.20) блоки try-catch или блоки catch, содержащие оператор break, то любые блоки catch таких операторов try выполняются в порядке, от самого внутреннего к самому внешнему, прежде чем управление передается цели break. Неожиданное завершение блока catch может нарушить передачу управления, инициированную оператором 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 с меткой Идентификатор пытается передать управление к оператору с этой же меткой Идентификатор (см. §14.7), который находится в охватывающей области; этот оператор, называемый целью оператора continue, затем немедленно завершает текущую итерацию и начинает новую.

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

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

Оператор continue должен ссылаться на метку в ближайшем методе, конструкторе или инициализаторе. Нет переходов на другие области. Если оператор continue не находится в цикле, операторе while, операторе do или операторе for с меткой Идентификатор в ближайшем методе, конструкторе или инициализаторе, возникает ошибка компиляции.

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

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

В приведенных описаниях используется фраза "пытается передать управление", а не просто "передаёт управление", потому что если в целевом операторе continue есть операторы try (§14.20), блоки try или catch которых содержат оператор continue, то все блоки catch этих операторов try выполняются в порядке, от внутреннего к внешнему, перед передачей управления целевому оператору continue. Прерывание выполнения блока catch может нарушить передачу управления, инициированную оператором 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, §15.12) или конструктора (§8.8, §15.9).

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

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

Оператор return без Выражения должен находиться в методе, объявленном с помощью ключевого слова void, не возвращающим значения (§8.4), или в конструкторе; в противном случае возникает ошибка компиляции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

made it!