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

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

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

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

Термины "завершить нормально" и "завершить преждевременно" также применяются к вычислению выражений (§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.3 для Тип. Следующие правила из §4.3, §8.4.1 и §8.3 приведены здесь для удобства:

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

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

Правила для модификаторов аннотаций при объявлении локальной переменной описаны в §9.7.4 и §9.7.5.

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

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

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

Для упрощения представления первое Выражение в обоих формах утверждения assert обозначается как Expression1. Во второй форме утверждения assert второе Выражение обозначается как Expression2.

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

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

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

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

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

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

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

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

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

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, будет брошено исключение, и оператор switch завершится внезапно по этой причине. В противном случае, если результат имеет ссылочный тип, он подвергается приведению к неупакованному типу (§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, оператору for или оператору try-with-resources в немедленно окружающем методе или инициализаторе; этот оператор, который называется целью break, затем немедленно завершается нормально.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Оператор throw вызывает исключение (§11 (Исключения)) для обработки. Результатом является немедленный переход управления (§11.3), который может завершить выполнение нескольких операторов и вызовов конструкторов, инициализаторов экземпляров, статических инициализаторов и инициализаторов полей, а также вызовов методов, пока не будет найден оператор try (§14.20), который перехватывает сгенерированное значение. Если такой оператор 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 методы на объекте. Другие потоки также могут использовать 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!