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

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

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

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

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

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

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

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

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

Неактивный оператор утверждения не делает ничего. В частности, ни Expression1, ни Expression2 (если он присутствует) не оцениваются. Выполнение неактивного оператора утверждения всегда завершается нормально.

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

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

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

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

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

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

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

Оператор 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:

Инструкция 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 может встречаться только в операторе while, операторе do или операторе for; операторы этих трех типов называются операторами итерации. Управление передается точке продолжения цикла оператора итерации.

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

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

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

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

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

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

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

Следовательно, оператор continue всегда завершается внезапно.

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

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

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

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

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

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

Оператор return возвращает управление вызывающей стороне метода (§8.4, §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 завершается по этой причине. Если вычисление Выражения завершается успешно, создавая значение V, то оператор 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;
            }
        };
    }
}