Глава 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. Если утверждение неактивное, выполнение утверждения не оказывает никакого эффекта.

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

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

Если во второй форме утверждения Выражение2 является 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

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

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

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

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

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

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

В свете этого утверждения не следует использовать для проверки аргументов в 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.

В предыдущих описаниях используется "пытается передать управление", а не просто "передаёт управление", потому что если есть операторы 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) выражение switch, которое включает оператор 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` обычным образом для достижения взаимного исключения.

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;
            }
        };
    }
}