Глава 14. Блоки, операторы и шаблоны

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

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

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

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

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

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

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

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

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

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

Локальный класс — это вложенный класс (§8 (Классы)), объявление которого непосредственно содержится в блоке (§14.2).

Локальный интерфейс — это вложенный интерфейс (§9 (Интерфейсы)), объявление которого непосредственно содержится в блоке.

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

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

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

Если объявление локального класса или интерфейса имеет модификатор static (§8.1.1.4), sealed или non-sealed (§8.1.1.2, §9.1.1.4), это является ошибкой компиляции.

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

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

Локальный класс может быть обычным классом (§8.1), классом перечисления (§8.9) или классом записи (§8.10). Каждый локальный обычный класс является внутренним классом (§8.1.3). Каждый локальный класс перечисления и каждый локальный класс записи неявно static (§8.1.1.4), и поэтому не является внутренним классом.

Локальный интерфейс может быть обычным интерфейсом (§9.1), но не интерфейсом аннотаций (§9.6). Каждый локальный интерфейс неявно static (§9.1.1.3).

Как и анонимный класс (§15.9.5), локальный класс или интерфейс не является членом никакого пакета, класса или интерфейса (§7.1, §8.5). В отличие от анонимного класса, локальный класс или интерфейс имеет простое имя (§6.2, §6.7).

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

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

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

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

Если вычисление Выражения или последующее преобразование (если таковое имеется) завершится с ошибкой, то оператор 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:

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

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

Если у оператора break нет цели break, то это ошибка компиляции.

Если цель break содержит какой-либо метод, конструктор, инициализатор экземпляра, статический инициализатор, лямбда-выражение или выражение switch, которое включает оператор break, то это ошибка компиляции. То есть, нет переходов вне блока.

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

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

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

В предыдущих описаниях говорится "пытается передать управление", а не просто "передает управление", потому что если есть любые операторы try (§14.20) внутри цели break, блоки 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 может использоваться только в операторе цикла, операторе цикла с условием или операторе цикла с параметрами; операторы этих трёх типов называются операторами итерации. Управление передаётся к точке продолжения цикла оператора итерации.

Существуют два типа оператора continue:

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

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

Ошибка компиляции возникает, если у оператора continue нет цели continue.

Ошибка компиляции возникает, если цель continue содержит любой метод, конструктор, инициализатор экземпляра, статический инициализатор, лямбда-выражение или выражение switch, которое включает оператор continue. То есть, нет нелокальных переходов.

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

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

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

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

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

Существуют два типа оператора return:

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

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

Ошибка компиляции возникает, если цель return содержит (i) инициализатор экземпляра или статический инициализатор, который включает оператор return, или (ii) лямбда-выражение, которое включает оператор return.

Ошибка компиляции возникает, если целью return оператора return без значения является метод, и этот метод не объявлен как void.

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

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

Выполнение оператора return без значения всегда завершается прерыванием, причиной является return без значения.

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

Таким образом, оператор 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, совпадают с блокировками, которые неявно приобретаются методами 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!

Оператор yield передает управление, заставляя включающее выражение switch (§15.28) генерировать указанное значение.

Оператор yield пытается передать управление во внутреннее включающее выражение switch; это включающее выражение, которое называется целью yield, затем немедленно завершается нормально, и значение Выражения становится значением выражения switch.

Если у оператора yield нет цели yield, возникает ошибка компиляции.

Если цель yield содержит методы, конструкторы, инициализаторы экземпляров, статические инициализаторы или лямбда-выражения, которые включают оператор yield, возникает ошибка компиляции. То есть, нет переходов на нелокальные метки.

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

Выполнение оператора yield сначала вычисляет Выражение. Если вычисление Выражения завершается прерывисто по какой-либо причине, то оператор yield завершается прерывисто по этой причине. Если вычисление Выражения завершается нормально, произведя значение V, то оператор yield завершается прерывисто, причиной является yield со значением V.

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

 class Test {
    enum Day {
        MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY,
	SATURDAY, SUNDAY
    }

    public int calculate(Day d) {
        return switch (d) {
	    case SATURDAY, SUNDAY -> d.ordinal();
            default -> {
                int len = d.toString().length();
                yield len*len;
            }
        };
    }
}

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

Процесс проверки значения по отношению к шаблону известен как сопоставление шаблонов. Если значение успешно соответствует шаблону, то процесс сопоставления шаблонов инициализирует переменную шаблона, объявленную шаблоном.

Переменные шаблона находятся в области видимости (§6.3) только там, где удается сопоставление шаблонов, и, следовательно, переменные шаблона будут инициализированы. Невозможно использовать переменную шаблона, которая не была инициализирована.