Spec-Zone .ru спецификации, руководства, описания, API

ГЛАВА 14

Блоки и Операторы

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

Некоторые операторы содержат другие операторы как часть их структуры; такие другие операторы являются подоператорами оператора. Мы говорим, что оператор S сразу содержит оператор U, если нет никакого оператора T, отличающегося от S, и U так, что S содержит T, и T содержит U. Тем же самым способом некоторые операторы содержат выражения (§15) как часть их структуры.

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

Блоки объясняются сначала (§14.2), сопровождаются объявлениями локального класса (§14.3) и операторы объявления локальной переменной (§14.4).

Затем грамматический маневр, который обходит знакомое "свисание else"проблема (§14.5) объясняется.

Последний раздел (§14.21) этой главы адресует требование что каждый оператор быть достижимым в определенном техническом смысле.

14.1 Нормальное и Резкое Завершение Операторов

• break (§14.15), continue (§14.16), и return операторы (§14.17) вызывают передачу управления, которое может предотвратить нормальное завершение операторов, которые содержат их.
• Оценка определенных выражений может выдать исключения от виртуальной машины Java; эти выражения получаются в итоге в §15.6. Явное throw (§14.18) оператор также приводит к исключению. Исключение вызывает передачу управления, которое может предотвратить нормальное завершение операторов.

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

• A break без метки
• A break с данной меткой
• A continue без метки
• A continue с данной меткой
• A return без значения
• A return с данным значением
• A throw с данным значением, включая исключения, выданные виртуальной машиной Java

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

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

Если иначе не определено, оператор обычно завершается, если все выражения, которые он оценивает и все подоператоры, которые он выполняет полный обычно.

14.2 Блоки

Block:
        { BlockStatementsopt }

BlockStatements:
        BlockStatement
        BlockStatements BlockStatement

BlockStatement:
        LocalVariableDeclarationStatement
        ClassDeclaration
        Statement
        

14.3 Объявления Локального класса

Контекст локального класса, сразу включенного блоком (§14.2), является остальной частью сразу блока включения, включая его собственное объявление класса. Контекст локального класса, сразу включенного в группе оператора блока переключателя (§14.11), является остальной частью сразу группы оператора блока переключателя включения, включая ее собственное объявление класса.

Имя локального класса C не может быть повторно объявлено как локальный класс непосредственно метода включения, конструктора, или блока инициализатора в рамках C, или ошибка времени компиляции происходит. Однако, объявление локального класса может быть затенено (§6.3.1) где угодно в объявлении класса, вложенном в пределах контекста объявления локального класса. У локального класса нет канонического имени, и при этом у него нет полностью определенного имени.

Это - ошибка времени компиляции, если объявление локального класса содержит кого-либо из следующих модификаторов доступа: public, protected, private, или static.

Вот пример, который иллюстрирует несколько аспектов правил, данных выше:

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
}

Факт, что контекст локального класса охватывает свое собственное объявление (не только его тело) означает что определение локального класса Cyclic является действительно циклическим, потому что это расширяет себя, а не Global.Cyclic. Следовательно, объявление локального класса Cyclic будет отклонен во время компиляции.

Так как имена локального класса не могут быть повторно объявлены в пределах того же самого метода (или конструктор или инициализатор, в зависимости от обстоятельств), вторые и третьи объявления Local результат в ошибках времени компиляции. Однако, Local может быть повторно объявлен в контексте другого, более глубоко вложен, класс такой как AnotherLocal.

Четвертое и последнее объявление Local является законным, так как это происходит вне контекста любого предшествующего объявления Local.

14.4 Операторы объявления Локальной переменной

LocalVariableDeclarationStatement:
        LocalVariableDeclaration ;

LocalVariableDeclaration:
        VariableModifiers Type VariableDeclarators
        

VariableDeclarators:
        VariableDeclarator
        VariableDeclarators , VariableDeclarator

VariableDeclarator:
        VariableDeclaratorId
        VariableDeclaratorId = VariableInitializer

VariableDeclaratorId:
        Identifier
        VariableDeclaratorId [ ]

VariableInitializer:
        Expression
        ArrayInitializer
        

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

14.4.1 Операторы объявления Локальной переменной и Типы

Если дополнительный финал ключевого слова появляется в начале оператора объявления, объявляемая переменная является заключительной переменной (§4.12.4).

Если аннотация на объявлении локальной переменной соответствует типу T аннотации, и T имеет (мета-) аннотация м., который соответствует annotation.Target, тогда у м. должен быть элемент, значение которого annotation.ElementType.LOCAL_VARIABLE, или ошибка времени компиляции происходит. Модификаторы аннотации описываются далее в (§9.7).

Тип переменной обозначается Типом, который появляется в объявлении локальной переменной, сопровождаемом любыми парами скобки, которые следуют за Идентификатором в операторе объявления.

Таким образом, объявление локальной переменной:

int a, b[], c[][];

int a;
int[] b;
int[][] c;

float[][] f[][], g[][][], h[];                                                                                                 // Yechh!

float[][][][] f;
float[][][][][] g;
float[][][] h;

Локальная переменная типа float всегда содержит значение, которое является элементом набора значений плавающего (§4.2.3); точно так же локальная переменная типа double всегда содержит значение, которое является элементом двойного набора значений. Это не разрешается для локальной переменной типа float чтобы содержать элемент набора значений "пускают в ход расширенную экспоненту", которая не является также элементом набора значений плавающего, ни для локальной переменной типа double чтобы содержать элемент набора значений "удваивают расширенную экспоненту", которая не является также элементом двойного набора значений.

14.4.2 Контекст Объявлений Локальной переменной

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

Локальная переменная не может быть отнесена в использование полностью определенного имени (§6.6), только простое имя.

Пример:

class Test {
        static int x;
        public static void main(String[] args) {
                int x = x;
        }
}

Следующая программа действительно компилирует:

class Test {
        static int x;
        public static void main(String[] args) {
                int x = (x=2)*2;
                System.out.println(x);
        }
}

4

Вот другой пример:

class Test {
        public static void main(String[] args) {
                System.out.print("2+1=");
                int two = 2, three = two + 1;
                System.out.println(three);
        }
}

2+1=3

Контекст локальной переменной объявляется в a for оператор является остальной частью for оператор, включая его собственный инициализатор.

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

Таким образом следующий пример не компилирует:

class Test {
        public static void main(String[] args) {
                int i;
                for (int i = 0; i < 10; i++)
                        System.out.println(i);
        }
}

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

class Test {
        public static void main(String[] args) {
                int i;
                class Local {
                        {
                                for (int i = 0; i < 10; i++)
                                System.out.println(i);
                        }
                }
                new Local();
        }
}

С другой стороны локальные переменные с тем же самым именем могут быть объявлены в двух отдельных блоках или for операторы, ни один из которых не содержит другой. Таким образом:

class Test {
        public static void main(String[] args) {
                for (int i = 0; i < 10; i++)
                        System.out.print(i + " ");
                for (int i = 10; i > 0; i--)
                        System.out.print(i + " ");
                System.out.println();
        }
}

0 1 2 3 4 5 6 7 8 9 10 9 8 7 6 5 4 3 2 1

14.4.3 Затенение Имен Локальными переменными

Например, ключевое слово this может использоваться, чтобы получить доступ к затененному полю x, использование формы this.x. Действительно, эта идиома обычно появляется в конструкторах (§8.8):

class Pair {
        Object first, second;
        public Pair(Object first, Object second) {
                this.first = first;
                this.second = second;
        }
}

14.4.4 Выполнение Объявлений Локальной переменной

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

14.5 Операторы

Как в 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 которому это могло бы возможно принадлежать. Это правило получается следующей грамматикой:

Statement:
        StatementWithoutTrailingSubstatement
        LabeledStatement
        IfThenStatement
        IfThenElseStatement
        WhileStatement
        ForStatement

StatementWithoutTrailingSubstatement:
        Block
        EmptyStatement
        ExpressionStatement
        AssertStatement
        SwitchStatement
        DoStatement
        BreakStatement
        ContinueStatement
        ReturnStatement
        SynchronizedStatement
        ThrowStatement
        TryStatement

StatementNoShortIf:
        StatementWithoutTrailingSubstatement
        LabeledStatementNoShortIf
        IfThenElseStatementNoShortIf
        WhileStatementNoShortIf
        ForStatementNoShortIf
        

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

IfThenStatement:
        if ( Expression ) Statement

IfThenElseStatement:
        if ( Expression ) StatementNoShortIf else Statement

IfThenElseStatementNoShortIf:
        if ( Expression ) StatementNoShortIf else StatementNoShortIf

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

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

14.6 Пустой Оператор

EmptyStatement:
        ;
        

14.7 Помеченные операторы

LabeledStatement:
        Identifier : Statement

LabeledStatementNoShortIf:
        Identifier : StatementNoShortIf

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

Позвольте l быть меткой, и позволять м. быть сразу методом включения, конструктором, инициализатором экземпляра или статическим инициализатором. Это - ошибка времени компиляции если l тени (§6.3.1) объявление другой метки, сразу включенной в м.

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

Помеченный оператор выполняется, выполняя сразу содержавший Оператор. Если оператор маркируется Идентификатором, и содержавший Оператор завершается резко из-за a break с тем же самым Идентификатором тогда помеченный оператор обычно завершается. Во всех других случаях резкого завершения Оператора помеченный оператор завершается резко по той же самой причине.

14.8 Операторы выражения

ExpressionStatement:
        StatementExpression ;

StatementExpression:
        Assignment
        PreIncrementExpression
        PreDecrementExpression
        PostIncrementExpression
        PostDecrementExpression
        MethodInvocation
        ClassInstanceCreationExpression
        

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

(void) ... ;           // incorrect!

14.9 Если Оператор

IfThenStatement:
        if ( Expression ) Statement

IfThenElseStatement:
        if ( Expression ) StatementNoShortIf else Statement

IfThenElseStatementNoShortIf:
        if ( Expression ) StatementNoShortIf else StatementNoShortIf

14.9.1 Если тогда Оператор

• Если значение true, тогда содержавший Оператор выполняется; if-then оператор обычно завершается, если и только если выполнение Оператора обычно завершается.
• Если значение false, никакие дальнейшие меры не предпринимаются и if-then оператор обычно завершается.

14.9.2 Оператор, "если тогда еще"

• Если значение true, тогда первый содержавший Оператор (один перед else ключевое слово), выполняется; if-then-else оператор обычно завершается, если и только если выполнение того оператора обычно завершается.
• Если значение false, тогда второй содержавший Оператор (один после else ключевое слово), выполняется; if-then-else оператор обычно завершается, если и только если выполнение того оператора обычно завершается.

14.10 оператор контроля

AssertStatement:

        assert Expression1 ;

   assert Expression1 : Expression2 ;

Утверждения могут быть включены или отключены на основе на класс. В то время, когда класс инициализируется (§12.4.2) до выполнения любых полевых инициализаторов для переменных класса (§8.3.2.1) и статических инициализаторов (§8.7), загрузчик класса класса определяет, включаются ли утверждения или отключаются как описано ниже. Как только класс был инициализирован, его состояние утверждения (включал, или отключенный) не изменяется.

Обсуждение

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

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

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

Обсуждение

Другими словами, если программа выше выполняется, не включая утверждениям, она должна напечатать:

Asserts enabled
Asserts disabled

assert оператор включается, если и только если высокоуровневый класс (§8), который лексически содержит это, включает утверждениям. Определяются ли высокоуровневые утверждения включений класса его загрузчиком класса определения прежде, чем класс будет инициализирован (§12.4.2), и не сможет быть изменен после того.

assert оператор вызывает высокоуровневый класс включения (если это существует) быть инициализированным, если это не было уже инициализировано (§12.4.1).

Обсуждение

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

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

Отключенный assert оператор ничего не делает. В особенности ни Expression1, ни Expression2 (если это присутствует) не оцениваются. Выполнение отключенного assert оператор всегда обычно завершается.

Включенный assert оператор выполняется первой оценкой Expression1. Если результат имеет тип Boolean, это подвергается распаковыванию преобразования (§5.1.8). Если оценка Expression1 или последующего преобразования распаковывания (если кто-либо) завершается резко по некоторым причинам, assert оператор завершается резко по той же самой причине. Иначе, выполнение продолжается, делая выбор, основанный на значении Expression1:

• Если значение true, никакие дальнейшие меры не предпринимаются, и оператор контроля обычно завершается.
• Если значение false, поведение при выполнении зависит от того, присутствует ли Expression2:
  • Если Expression2 присутствует, он оценивается.
    • Если оценка завершается резко по некоторым причинам, assert оператор завершается резко по той же самой причине.
    • Если оценка обычно завершается, получающееся значение преобразовывается в a String использование преобразования строк (§15.18.1.1).
      • Если преобразование строк завершается резко по некоторым причинам, assert оператор завершается резко по той же самой причине.
      • Если преобразование строк обычно завершается, AssertionError экземпляр, чей "сообщение детали" является результатом преобразования строк, создается.
        • Если создание экземпляра завершается резко по некоторым причинам, assert оператор завершается резко по той же самой причине.
        • Если создание экземпляра обычно завершается, assert оператор завершается резко, бросая недавно создаваемый AssertionError объект.
  • Если Expression2 не присутствует, AssertionError экземпляр без "сообщения детали" создается.
    • Если создание экземпляра завершается резко по некоторым причинам, assert оператор завершается резко по той же самой причине.
    • Если создание экземпляра обычно завершается, assert оператор завершается резко, бросая недавно создаваемый AssertionError объект.

Обсуждение

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

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

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

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

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

Другая проблема с использованием утверждений для проверки параметра состоит в том, что ошибочные параметры должны привести к соответствующему исключению на этапе выполнения (такой как IllegalArgumentException, IndexOutOfBoundsException или NullPointerException). Отказ утверждения не будет выдавать соответствующее исключение. Снова, это не недопустимо, чтобы использовать утверждения для параметра, проверяющего открытые методы, но это является обычно несоответствующим. Это предназначается это AssertionError никогда не будьте пойманы, но возможно сделать так, таким образом правила для try операторы должны обработать утверждения, появляющиеся в a try блокируйте так же к текущей обработке операторов броска.

14.11 оператор переключения

SwitchStatement:
        switch ( Expression ) SwitchBlock

SwitchBlock:
        { SwitchBlockStatementGroupsopt SwitchLabelsopt }

SwitchBlockStatementGroups:
        SwitchBlockStatementGroup
        SwitchBlockStatementGroups SwitchBlockStatementGroup

SwitchBlockStatementGroup:
        SwitchLabels BlockStatements

SwitchLabels:
        SwitchLabel
        SwitchLabels SwitchLabel

SwitchLabel:
        case ConstantExpression :
        case EnumConstantName :
        default :

EnumConstantName:
        Identifier
        

Тело a switch оператор известен как блок переключателя. Любой оператор, сразу содержавший блоком переключателя, может быть маркирован один или больше case или default метки. Эти метки, как говорят, связываются с switch оператор, как значения константных выражений (§15.28) в case метки.

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

• Каждый case константное выражение связалось с a switch оператор должен быть присваиваемым (§5.2) типу switch Выражение.
• Никакая метка переключателя не null.
• Никакие два из case константные выражения связались с a switch у оператора может быть то же самое значение.
• Самое большее один default метка может быть связана с тем же самым switch оператор.

Обсуждение

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

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

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

В C и C++ тело a switch оператор может быть оператором и операторами с case метки не должны сразу содержаться тем оператором. Рассмотрите простой цикл:

for (i = 0; i < n; ++i) foo();

int q = (n+7)/8;
switch (n%8) {
case 0:         do {    foo();          // Great C hack, Tom,
case 7:                 foo();          // but it's not valid here.
case 6:                 foo();
case 5:                 foo();
case 4:                 foo();
case 3:                 foo();
case 2:                 foo();
case 1:                 foo();
                } while (--q > 0);
}

Когда switch оператор выполняется, сначала Выражение оценивается. Если Выражение оценивает к null, a NullPointerException бросается и все switch оператор завершается резко по этой причине. Иначе, если результат имеет ссылочный тип, это подвергается распаковыванию преобразования (§5.1.8). Если оценка Выражения или последующего преобразования распаковывания (если кто-либо) завершается резко по некоторым причинам, switch оператор завершается резко по той же самой причине. Иначе, выполнение продолжается, сравнивая значение Выражения с каждым case постоянный. Затем есть выбор:

• Если один из case константы равны значению выражения, тогда мы говорим что case соответствия, и все операторы после соответствия case метка в блоке переключателя, если таковые вообще имеются, выполняется в последовательности. Если все эти операторы обычно завершаются, или если нет никаких операторов после соответствия case метка, тогда все switch оператор обычно завершается.
• Если нет case соответствия, но есть a default метка, тогда все операторы после соответствия default метка в блоке переключателя, если таковые вообще имеются, выполняется в последовательности. Если все эти операторы обычно завершаются, или если нет никаких операторов после default метка, тогда все switch оператор обычно завершается.
• Если нет case соответствия и есть нет default метка, тогда никакие дальнейшие меры не предпринимаются и switch оператор обычно завершается.

• Если выполнение Оператора завершается резко из-за a break без метки никакие дальнейшие меры не предпринимаются и switch оператор обычно завершается.
• Если выполнение Оператора завершается резко по какой-либо другой причине, switch оператор завершается резко по той же самой причине. Случай резкого завершения из-за a break с меткой обрабатывается общим правилом для помеченных операторов (§14.7).

Например, программа:

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

14.12, в то время как Оператор

WhileStatement:
        while ( Expression ) Statement

WhileStatementNoShortIf:
        while ( Expression ) StatementNoShortIf

A while оператор выполняется первой оценкой Выражения. Если результат имеет тип Boolean, это подвергается распаковыванию преобразования (§5.1.8). Если оценка Выражения или последующего преобразования распаковывания (если кто-либо) завершается резко по некоторым причинам, while оператор завершается резко по той же самой причине. Иначе, выполнение продолжается, делая выбор, основанный на получающемся значении:

• Если значение true, тогда содержавший Оператор выполняется. Затем есть выбор:
  • Если выполнение Оператора обычно завершается, то все while оператор выполняется снова, начинаясь, переоценивая Выражение.
  • Если выполнение Оператора завершается резко, см. §14.12.1 ниже.
• Если (возможно распакованный) значение Выражения false, никакие дальнейшие меры не предпринимаются и while оператор обычно завершается.

14.12.1 Резкое Завершение

• Если выполнение Оператора завершается резко из-за a break без метки никакие дальнейшие меры не предпринимаются и while оператор обычно завершается.
  • Если выполнение Оператора завершается резко из-за a continue без метки, тогда все while оператор выполняется снова.
  • Если выполнение Оператора завершается резко из-за a continue с меткой L тогда есть выбор:
    • Если while у оператора есть метка L, тогда все while оператор выполняется снова.
    • Если while у оператора нет метки L, while оператор завершается резко из-за a continue с меткой L.
  • Если выполнение Оператора завершается резко по какой-либо другой причине, while оператор завершается резко по той же самой причине. Отметьте что случай резкого завершения из-за a break с меткой обрабатывается общим правилом для помеченных операторов (§14.7).

14.13 делают Оператор

DoStatement:
        do Statement while ( Expression ) ;

A do оператор выполняется первым выполнением Оператора. Затем есть выбор:

• Если выполнение Оператора обычно завершается, то Выражение оценивается. Если результат имеет тип Boolean, это подвергается распаковыванию преобразования (§5.1.8). Если оценка Выражения или последующего преобразования распаковывания (если кто-либо) завершается резко по некоторым причинам, do оператор завершается резко по той же самой причине. Иначе, есть выбор, основанный на получающемся значении:
  • Если значение true, тогда все do оператор выполняется снова.
  • Если значение false, никакие дальнейшие меры не предпринимаются и do оператор обычно завершается.
• Если выполнение Оператора завершается резко, см. §14.13.1 ниже.

14.13.1 Резкое Завершение

• Если выполнение Оператора завершается резко из-за a break без метки тогда никакие дальнейшие меры не предпринимаются и do оператор обычно завершается.
• Если выполнение Оператора завершается резко из-за a continue без метки тогда оценивается Выражение. Затем есть выбор, основанный на получающемся значении:
  • Если значение true, тогда все do оператор выполняется снова.
  • Если значение false, никакие дальнейшие меры не предпринимаются и do оператор обычно завершается.
• Если выполнение Оператора завершается резко из-за a continue с меткой L тогда есть выбор:
  • Если do у оператора есть метка L, тогда Выражение оценивается. Затем есть выбор:
    • Если значение Выражения true, тогда все do оператор выполняется снова.
    • Если значение Выражения false, никакие дальнейшие меры не предпринимаются и do оператор обычно завершается.
  • Если do у оператора нет метки L, do оператор завершается резко из-за a continue с меткой L.
• Если выполнение Оператора завершается резко по какой-либо другой причине, do оператор завершается резко по той же самой причине. Случай резкого завершения из-за a break с меткой обрабатывается общим правилом (§14.7).

14.13.2 Пример делает оператор

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

14.14 для Оператора

ForStatement:
        BasicForStatement
        EnhancedForStatement

• Основное for оператор.
• Улучшенный for оператор

14.14.1 Основное для Оператора

BasicForStatement:
        for ( ForInitopt ; Expressionopt ; ForUpdateopt ) Statement

ForStatementNoShortIf:
        for ( ForInitopt ; Expressionopt ; ForUpdateopt )
         StatementNoShortIf

ForInit:
        StatementExpressionList
        LocalVariableDeclaration

ForUpdate:
        StatementExpressionList

StatementExpressionList:
        StatementExpression
        StatementExpressionList , StatementExpression
        

14.14.1.1 Инициализация для оператора

• Если код ForInit является списком выражений оператора (§14.8), выражения оцениваются в последовательности слева направо; их значения, если таковые вообще имеются, отбрасываются. Если оценка какого-либо выражения завершается резко по некоторым причинам, for оператор завершается резко по той же самой причине; любые выражения оператора ForInit направо от того, который завершался резко, не оцениваются.

• Его собственный инициализатор
• Дальнейшие операторы объявления направо в части ForInit for оператор
• Части Выражения и ForUpdate for оператор
• Содержавший Оператор

• Если часть ForInit не присутствует, никакие меры не предпринимаются.

14.14.1.2 Итерация для оператора

• Если Выражение присутствует, оно оценивается. Если результат имеет тип Boolean, это подвергается распаковыванию преобразования (§5.1.8). Если оценка Выражения или последующего преобразования распаковывания (если кто-либо) завершается резко, for оператор завершается резко по той же самой причине. Иначе, есть тогда выбор, основанный на присутствии или отсутствии Выражения и получающегося значения, если Выражение присутствует:
  • Если Выражение не присутствует, или оно присутствует, и значение, следующее из его оценки (включая любое возможное распаковывание), true, тогда содержавший Оператор выполняется. Затем есть выбор:
    • Если выполнение Оператора обычно завершается, то следующие два шага выполняются в последовательности:
      • Во-первых, если часть ForUpdate присутствует, выражения оцениваются в последовательности слева направо; их значения, если таковые вообще имеются, отбрасываются. Если оценка какого-либо выражения завершается резко по некоторым причинам, for оператор завершается резко по той же самой причине; любые выражения оператора ForUpdate направо от того, который завершался резко, не оцениваются. Если часть ForUpdate не присутствует, никакие меры не предпринимаются.
      • Во-вторых, другой for итеративный шаг выполняется.
    • Если выполнение Оператора завершается резко, см. §14.14.1.3 ниже.
  • Если Выражение присутствует, и значение, следующее из его оценки (включая любое возможное распаковывание), false, никакие дальнейшие меры не предпринимаются и for оператор обычно завершается.

Если Выражение не присутствует, то единственный путь a for оператор может завершиться, обычно при помощи a break оператор.

14.14.1.3 Резкое Завершение для оператора

• Если выполнение Оператора завершается резко из-за a break без метки никакие дальнейшие меры не предпринимаются и for оператор обычно завершается.
• Если выполнение Оператора завершается резко из-за a continue без метки тогда следующие два шага выполняются в последовательности:
  • Во-первых, если часть ForUpdate присутствует, выражения оцениваются в последовательности слева направо; их значения, если таковые вообще имеются, отбрасываются. Если часть ForUpdate не присутствует, никакие меры не предпринимаются.
  • Во-вторых, другой for итеративный шаг выполняется.
• Если выполнение Оператора завершается резко из-за a continue с меткой L тогда есть выбор:
  • Если for у оператора есть метка L, тогда следующие два шага выполняются в последовательности:
    • Во-первых, если часть ForUpdate присутствует, выражения оцениваются в последовательности слева направо; их значения, если таковые вообще имеются, отбрасываются. Если ForUpdate не присутствует, никакие меры не предпринимаются.
    • Во-вторых, другой for итеративный шаг выполняется.
  • Если for у оператора нет метки L, for оператор завершается резко из-за a continue с меткой L.
• Если выполнение Оператора завершается резко по какой-либо другой причине, for оператор завершается резко по той же самой причине. Отметьте что случай резкого завершения из-за a break с меткой обрабатывается общим правилом для помеченных операторов (§14.7).

14.14.2 Улучшенный для оператора

EnhancedForStatement:
        for ( VariableModifiersopt Type Identifier: Expression) Statement

Контекст локальной переменной объявляется в части FormalParameter улучшенного for оператором (§14.14) является содержавший Оператор

Значение улучшенного for оператор дается преобразованием в основное for оператор.

Если тип Выражения является подтипом Iterable, тогда позвольте мне быть типом Выражения выражения.iterator(). Улучшенный for оператор эквивалентен основному for оператор формы:

for (I #i = Expression.iterator(); #i.hasNext(); ) {

        VariableModifiersopt Type Identifier = #i.next();
   Statement
}

Иначе, Выражение обязательно сделало, чтобы массив ввел, T []. Позвольте _L1... _Lm быть (возможно пустой) последовательностью меток, сразу предшествующих улучшенному for оператор. Затем значение улучшенного for оператор дается следующим основным for оператор:

T[] a = Expression;
L1: L2: ... Lm:
for (int i = 0; i < a.length; i++) {
        VariableModifiersopt Type Identifier = a[i];
        Statement
}

Обсуждение

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

    int sum(int[] a) {
        int sum = 0;
        for (int i : a)
            sum += i;
        return sum;
    }
        

    Map<String, Integer> histogram = ...;
    double total = 0;
    for (int i : histogram.values())
        total += i;
    for (Map.Entry<String, Integer> e : histogram.entrySet())
        System.out.println(e.getKey() + "       " + e.getValue() / total);

14.15 оператор завершения

BreakStatement:
        break Identifieropt ;

Быть точным, a break оператор без метки всегда завершается резко, причина, являющаяся a break без метки. Если нет switch, while, do, или for оператор в сразу методе включения, конструкторе или инициализаторе включает break оператор, ошибка времени компиляции происходит.

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

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

Это может быть замечено, тогда, это a break оператор всегда завершается резко.

Предыдущие описания говорят "попытки передать управление", а не только "управление передачами" потому что, если есть кто-либо try операторы (§14.20) в пределах повреждения предназначаются чей try блоки содержат break оператор, тогда любой finally пункты тех try операторы выполняются, в порядке, самом внутреннем к наиболее удаленному, прежде, чем управление будет передано цели повреждения. Резкое завершение a finally пункт может разрушить передачу управления, инициируемого a break оператор.

В следующем примере математический график представляется массивом массивов. График состоит из ряда узлов и ряда краев; каждый край является стрелкой, которая указывает от некоторого узла до некоторого другого узла, или от узла до себя. В этом примере предполагается, что нет никаких избыточных краев; то есть, для любых двух узлов P и Q, где Q может быть тем же самым как P, есть самое большее один край от P до К. Ноудса, представляются целыми числами, и есть край от узла i к узлу edges[i] то [j] для каждого я и j, для который ссылка массива edges[i] [j] не бросает IndexOutOfBoundsException.

Задача метода loseEdges, данный целые числа i и j, должен создать новый график, копируя данный график, но опуская край от узла i к узлу j, если таковые вообще имеются, и краю от узла j к узлу i, если любой:

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

14.16 продолжать Оператор

ContinueStatement:
        continue Identifieropt ;

Быть точным, такой continue оператор всегда завершается резко, причина, являющаяся a continue без метки. Если нет while, do, или for оператор сразу метода включения или блока инициализатора включает continue оператор, ошибка времени компиляции происходит.

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

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

Это может быть замечено, тогда, это a continue оператор всегда завершается резко.

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

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

В Graph пример в предыдущем разделе, одном из break операторы используются, чтобы закончить выполнение всего тела наиболее удаленного for цикл. Это break может быть заменен a continue если for сам цикл маркируется:

class Graph {
        . . .
        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) {
                                        . . .
                                } else if (k == j) {
                                        . . .
                                }
                                newedges[k] = edges[k];
                                continue edgelists;
                        } // search
                        . . .
                } // edgelists
                return new Graph(newedges);
        }
}

14.17 оператор возврата

ReturnStatement:
        return Expressionopt ;

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

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

A return оператор с Выражением пытается передать управление invoker метода, который содержит это; значение Выражения становится значением вызова метода. Более точно, выполнение такого return оператор сначала оценивает Выражение. Если оценка Выражения завершается резко по некоторым причинам, то return оператор завершается резко по этой причине. Если оценка Выражения обычно завершается, производя значение V, то return оператор завершается резко, причина, являющаяся a return со значением V. Если выражение имеет тип float и не строго FP (§15.4), тогда значение может быть элементом или набора значений плавающего или набора значений "расширенная экспонента плавающая" (§4.2.3). Если выражение имеет тип double и не строго FP, тогда значение может быть элементом или двойного набора значений или набора значений "двойная расширенная экспонента".

Это может быть замечено, тогда, это a return оператор всегда завершается резко.

Предыдущие описания говорят "попытки передать управление", а не только "управление передачами" потому что, если есть кто-либо try операторы (§14.20) в пределах метода или конструктора, чей try блоки содержат return оператор, тогда любой finally пункты тех try операторы будут выполняться, в порядке, самом внутреннем к наиболее удаленному, прежде, чем управление будет передано invoker метода или конструктора. Резкое завершение a finally пункт может разрушить передачу управления, инициируемого a return оператор.

14.18 Оператор броска

ThrowStatement:
        throw Expression ;

Выражение в операторе броска должно обозначить переменную или значение ссылочного типа, который присваиваем (§5.2) типу Throwable, или ошибка времени компиляции происходит. Кроме того по крайней мере одно из следующих трех условий должно быть истиной, или ошибка времени компиляции происходит:

• Исключение не является проверенным исключением (§11.2) - определенно, одна из следующих ситуаций является истиной:
  • Тип Выражения является классом RuntimeException или подкласс RuntimeException.
  • Тип Выражения является классом Error или подкласс Error.
• throw оператор содержится в try блок a try оператор (§14.20) и тип Выражения присваиваем (§5.2) типу параметра по крайней мере одного catch пункт try оператор. (В этом случае мы говорим, что брошенное значение поймано try оператор.)
• throw оператор содержится в методе или объявлении конструктора, и тип Выражения присваиваем (§5.2) по крайней мере одному типу, перечисленному в throws пункт (§8.4.6, §8.8.5) объявления.

Это может быть замечено, тогда, это a throw оператор всегда завершается резко.

Если есть какое-либо включение try операторы (§14.20), чей try блоки содержат throw оператор, тогда любой finally пункты тех try операторы выполняются, поскольку управление передается исходящее, пока брошенное значение не поймано. Отметьте что резкое завершение a finally пункт может разрушить передачу управления, инициируемого a throw оператор.

Если a throw оператор содержится в объявлении метода, но его значение не поймано некоторыми try оператор, который содержит это, тогда вызов метода, завершается резко из-за throw.

Если a throw оператор содержится в объявлении конструктора, но его значение не поймано некоторыми try оператор, который содержит это, тогда выражение создания экземпляра класса, которое вызвало конструктора, завершится резко из-за throw.

Если a throw оператор содержится в статическом инициализаторе (§8.7), затем проверка времени компиляции гарантирует, что или ее значение всегда является исключением непроверенным или ее значением, всегда пойман некоторыми try оператор, который содержит это. Если во время выполнения, несмотря на эту проверку, значение не поймано некоторыми try оператор, который содержит throw оператор, тогда значение повторно бросается, если это - экземпляр класса Error или один из его подклассов; иначе, это обертывается в ExceptionInInitializerError объект, который тогда бросается (§12.4.2).

Если a throw оператор содержится в инициализаторе экземпляра (§8.6), затем проверка времени компиляции гарантирует, что или ее значение всегда является исключением непроверенным или ее значением, всегда пойман некоторым оператором попытки, который содержит это, или тип выданного исключения (или один из его суперклассов) происходит в пункте бросков каждого конструктора класса.

Условно, объявленный пользователем типами throwable, как должны обычно объявлять, подклассы класса Exception, который является подклассом класса Throwable (§11.5).

14.19 синхронизируемый Оператор

SynchronizedStatement:
        synchronized ( Expression ) Block

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

A synchronized оператор выполняется первой оценкой Выражения.

Если оценка Выражения завершается резко по некоторым причинам, то synchronized оператор завершается резко по той же самой причине.

Иначе, если значение Выражения null, a NullPointerException бросается.

Иначе, позвольте не -null значение Выражения быть V. Выполняющийся поток блокирует блокировку, связанную с V. Затем Блок выполняется. Если выполнение Блока обычно завершается, то блокировка разблокирована и synchronized оператор обычно завершается. Если выполнение Блока завершается резко по какой-либо причине, то блокировка разблокирована и synchronized оператор тогда завершается резко по той же самой причине.

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

Блокировки, полученные synchronized операторы являются тем же самым как блокировками, которые получаются неявно synchronized методы; см. §8.4.3.6. Единственный поток может содержать блокировку не раз.

Пример:

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

made it!

14.20 оператор попытки

TryStatement:
        try Block Catches
        try Block Catchesopt Finally

Catches:
        CatchClause
        Catches CatchClause

CatchClause:
        catch ( FormalParameter ) Block

Finally:
        finally Block

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

FormalParameter:
        VariableModifiers Type VariableDeclaratorId
        

VariableDeclaratorId:
        Identifier
        VariableDeclaratorId [ ]

A try оператор может иметь catch пункты (также названный обработчиками исключений). A catch у пункта должен быть точно один параметр (который вызывают параметром исключения); объявленный тип параметра исключения должен быть классом Throwable или подкласс (не только подтип) Throwable, или ошибка времени компиляции происходит. В частности это - ошибка времени компиляции, если объявленный тип параметра исключения является переменной типа (§4.4). Контекстом переменной параметра является Блок catch пункт.

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

Контекст параметра обработчика исключений, который объявляется в a catch пункт a try оператор (§14.20) является всем блоком, связанным с catch.

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

A try оператор может бросить эквивалентность типа E исключения также:

• try блок может бросить E, и E не присваиваем любому catch параметр try оператор и любой нет finally блок присутствует или finally блок может обычно завершаться; или
• Некоторые catch блок try оператор может бросить E и любого нет finally блок присутствует или finally блок может обычно завершаться; или
• A finally блок присутствует и может бросить E.

Это - ошибка времени компиляции, если параметр исключения, который объявляется финалом, присваивается в пределах тела пункта выгоды.

Это - ошибка времени компиляции если a catch выгоды пункта проверенный тип E1 исключения, но там не существует никакой проверенный тип E2 исключения так, что все следующее, содержат:

• E2 <: E1
• try блок, соответствующий catch пункт может бросить E2
• Нет предшествование catch блок немедленного включения try оператор ловит E2 или супертип E2.

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

Обработчики исключений рассматривают в слева направо порядке: самое раннее catch пункт принимает исключение, получая как его фактический параметр брошенный объект исключения.

A finally пункт гарантирует что finally блок выполняется после try блок и любой catch блок, который мог бы быть выполнен, независимо от того как листы управления try блок или catch блок.

Обработка finally блок довольно сложен, таким образом, два случая a try оператор с и без a finally блок описывается отдельно.

14.20.1 Выполнение выгоды попытки

• Если выполнение try блок обычно завершается, тогда никакие дальнейшие меры не предпринимаются и try оператор обычно завершается.
• Если выполнение try блок завершается резко из-за a throw из значения V, тогда есть выбор:
  • Если тип времени выполнения V присваиваем (§5.2) Параметру кого-либо catch пункт try оператор, тогда первое (крайнее левое) такой catch пункт выбирается. Значение V присваивается параметру выбранного catch пункт, и Блок этого catch пункт выполняется. Если тот блок обычно завершается, то try оператор обычно завершается; если тот блок завершается резко по любой причине, то try оператор завершается резко по той же самой причине.
  • Если тип времени выполнения V не присваиваем параметру кого-либо catch пункт try оператор, тогда try оператор завершается резко из-за a throw из значения V.
• Если выполнение try блок завершается резко по любой другой причине, тогда try оператор завершается резко по той же самой причине.

В примере:

class BlewIt extends Exception {
        BlewIt() { }
        BlewIt(String s) { super(s); }
}
class Test {
        static void blowUp() throws BlewIt { throw new BlewIt(); }
        public static void main(String[] args) {
                try {
                        blowUp();
                } catch (RuntimeException r) {
                        System.out.println("RuntimeException:" + r);
                } catch (BlewIt b) {
                        System.out.println("BlewIt");
                }
        }
}

BlewIt

14.20.2 Выполнение "попытки ловит наконец"

• Если выполнение try блок обычно завершается, тогда finally блок выполняется, и затем есть выбор:
  • Если finally блок обычно завершается, тогда try оператор обычно завершается.
  • Если finally блок завершается резко по причине S, тогда try оператор завершается резко по причине S.
• Если выполнение try блок завершается резко из-за a throw из значения V, тогда есть выбор:
  • Если тип времени выполнения V присваиваем параметру кого-либо catch пункт try оператор, тогда первое (крайнее левое) такой catch пункт выбирается. Значение V присваивается параметру выбранного catch пункт, и Блок этого catch пункт выполняется. Затем есть выбор:
    • Если catch блок обычно завершается, тогда finally блок выполняется. Затем есть выбор:
      • Если finally блок обычно завершается, тогда try оператор обычно завершается.
      • Если finally блок завершается резко по любой причине, тогда try оператор завершается резко по той же самой причине.
    • Если catch блок завершается резко по причине R, тогда finally блок выполняется. Затем есть выбор:
      • Если finally блок обычно завершается, тогда try оператор завершается резко по причине R.
      • Если finally блок завершается резко по причине S, тогда try оператор завершается резко по причине S (и причина R отбрасывается).
  • Если тип времени выполнения V не присваиваем параметру кого-либо catch пункт try оператор, тогда finally блок выполняется. Затем есть выбор:
    • Если finally блок обычно завершается, тогда try оператор завершается резко из-за a throw из значения V.
    • Если finally блок завершается резко по причине S, тогда try оператор завершается резко по причине S (и throw имеющий значение V отбрасывается и забывается).
• Если выполнение try блок завершается резко по любой другой причине R, тогда finally блок выполняется. Затем есть выбор:
  • Если finally блок обычно завершается, тогда try оператор завершается резко по причине R.
  • Если finally блок завершается резко по причине S, тогда try оператор завершается резко по причине S (и причина R отбрасывается).

Пример:

class BlewIt extends Exception {
        BlewIt() { }
        BlewIt(String s) { super(s); }
}
class Test {
        static void blowUp() throws BlewIt {
                throw new NullPointerException();
        }
        public static void main(String[] args) {
                try {
                        blowUp();
                } catch (BlewIt b) {
                        System.out.println("BlewIt");
                } finally {
                        System.out.println("Uncaught Exception");
                }
        }
}

Uncaught Exception
java.lang.NullPointerException
        at Test.blowUp(Test.java:7)
        at Test.main(Test.java:11)

Обсуждение

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

14.21 Недостижимых Операторов

Этот раздел посвящается точному объяснению "достижимого" слова. Идея состоит в том, что должен быть некоторый возможный путь выполнения с начала конструктора, метода, инициализатора экземпляра или статического инициализатора, который содержит оператор к оператору непосредственно. Анализ принимает во внимание структуру операторов. За исключением специального режима while, do, и for операторы, у выражения условия которых есть постоянная величина true, значения выражений не принимаются во внимание в анализе потоков.

Например, компилятор Java примет код:

{
        int n = 5;
        while (n > 7) k = 2;
}

Компилятор Java должен работать согласно правилам, размеченным в этом разделе.

Правила в этом разделе определяют два технических термина:

• достижим ли оператор
• может ли оператор обычно завершаться

Чтобы сократить описание правил, общепринятое сокращение "эквивалентность" используется, чтобы означать "если и только если."

Правила следующие:

• Блок, который является телом конструктора, метода, инициализатора экземпляра или статического инициализатора, достижим.
• Пустой блок, который не является блоком переключателя, может обычно завершать эквивалентность, это достижимо. Непустой блок, который не является блоком переключателя, может обычно завершать эквивалентность, которую последний оператор в нем может обычно завершать. Первый оператор в непустом блоке, который не является блоком переключателя, является достижимой эквивалентностью, блок достижим. Любой оператор S в непустом блоке, который не является блоком переключателя, является достижимой эквивалентностью, которую оператор, предшествующий S, может обычно завершать.
• Оператор объявления локального класса может обычно завершать эквивалентность, это достижимо.
• Оператор объявления локальной переменной может обычно завершать эквивалентность, это достижимо.
• Пустой оператор может обычно завершать эквивалентность, это достижимо.
• Помеченный оператор может обычно завершаться, если по крайней мере одно из следующего является истиной:
  • Содержавший оператор может обычно завершаться.
  • Есть достижимое break оператор, который выходит из помеченного оператора.

Содержавший оператор является достижимой эквивалентностью, помеченный оператор достижим.

• Оператор выражения может обычно завершать эквивалентность, это достижимо.
• if оператор, имеет ли это else часть, обрабатывается необычным способом. Поэтому это обсуждается отдельно в конце этого раздела.
• assert оператор может обычно завершать эквивалентность, это достижимо.
• A switch оператор может обычно завершать эквивалентность, по крайней мере одно из следующего является истиной:
  • Последний оператор в блоке переключателя может обычно завершаться.
  • Блок переключателя пуст или содержит только метки переключателя.
  • После последней группы оператора блока переключателя есть по крайней мере одна метка переключателя.
  • Блок переключателя не содержит a default метка.
  • Есть достижимое break оператор, который выходит switch оператор.
• Блок переключателя является достижимой эквивалентностью switch оператор достижим.
• Оператор в блоке переключателя является достижимой эквивалентностью switch оператор достижим, и по крайней мере одно из следующего является истиной:
  • Это переносит a case или default метка.
  • Есть оператор, предшествующий этому в switch блок и что предыдущий оператор может обычно завершаться.
• A while оператор может обычно завершать эквивалентность, по крайней мере одно из следующего является истиной:
  • while оператор достижим, и выражение условия не является константным выражением со значением true.
  • Есть достижимое break оператор, который выходит while оператор.

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

• A do оператор может обычно завершать эквивалентность, по крайней мере одно из следующего является истиной:
  • Содержавший оператор может обычно завершаться, и выражение условия не является константным выражением со значением true.
  • do оператор содержит достижимое continue оператор без метки, и do оператор сам внутренний while, do, или for оператор, который содержит это continue оператор, и выражение условия не являются константным выражением со значением true.
  • do оператор содержит достижимое continue оператор с меткой L, и do у оператора есть метка L, и выражение условия не является константным выражением со значением true.
  • Есть достижимое break оператор, который выходит do оператор.

Содержавший оператор является достижимой эквивалентностью do оператор достижим.

• Основное for оператор может обычно завершать эквивалентность, по крайней мере одно из следующего является истиной:
  • for оператор достижим, есть выражение условия, и выражение условия не является константным выражением со значением true.
  • Есть достижимое break оператор, который выходит for оператор.

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

• Улучшенный for оператор может обычно завершать эквивалентность, это достижимо.
• A break, continue, return, или throw оператор не может обычно завершаться.
• A synchronized оператор может обычно завершать эквивалентность, которую содержавший оператор может обычно завершать. Содержавший оператор является достижимой эквивалентностью synchronized оператор достижим.
• A try оператор может обычно завершаться, эквивалентность оба из следующего истина:
  • try блок может обычно завершаться или любой catch блок может завершиться normally.
  • Если try у оператора есть a finally блок, тогда finally блок может обычно завершаться.
• try блок является достижимой эквивалентностью try оператор достижим.
• A catch блок C является достижимой эквивалентностью оба из следующего, истина:
  • Некоторое выражение или throw оператор в try блок достижим и может выдать исключение, тип которого присваиваем параметру catch пункт C. (Выражение считают достижимой эквивалентностью самым внутренним оператором, содержащим это, достижим.)
  • Есть не ранее catch блокируйте в try оператор так, что тип параметра К является тем же самым как или подкласс типа параметра А.
• Если a finally блок присутствует, это - достижимая эквивалентность try оператор достижим.

Можно было бы ожидать if оператор, который будет обработан следующим способом, но они не правила, что язык программирования Java фактически использует:

• ГИПОТЕТИЧЕСКИЙ: if-then оператор может обычно завершать эквивалентность, которая по крайней мере одно из следующего true:
  • if-then оператор достижим, и выражение условия не является константным выражением, значение которого true.
  • then- оператор может обычно завершаться.
• then- оператор является достижимой эквивалентностью if-then оператор достижим, и выражение условия не является константным выражением, значение которого false.

• ГИПОТЕТИЧЕСКИЙ: if-then-else оператор может обычно завершать эквивалентность then- оператор может обычно завершаться или else- оператор может обычно завершаться. then- оператор является достижимой эквивалентностью if-then-else оператор достижим, и выражение условия не является константным выражением, значение которого false. else оператор является достижимой эквивалентностью if-then-else оператор достижим, и выражение условия не является константным выражением, значение которого true.

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

Фактические правила для, если оператор следующие:

• ФАКТИЧЕСКИЙ: if-then оператор может обычно завершать эквивалентность, это достижимо. then- оператор является достижимой эквивалентностью if-then оператор достижим.
• ФАКТИЧЕСКИЙ: if-then-else оператор может обычно завершать эквивалентность then- оператор может обычно завершаться или else- оператор может обычно завершаться. then- оператор является достижимой эквивалентностью if-then-else оператор достижим. else- оператор является достижимой эквивалентностью if-then-else оператор достижим.

Как пример, следующий оператор приводит к ошибке времени компиляции:

while (false) { x=3; }

if (false) { x=3; }

Объяснение для этой отличающейся обработки должно позволить программистам определять "переменные флага", такие как:

static final boolean DEBUG = false;

if (DEBUG) { x=3; }

Эта возможность к "условно компиляции" оказывает значительное влияние на, и отношение к, совместимость на уровне двоичных кодов (§13). Если ряд классов, которые используют такую переменную "флага", компилируется, и условный код опускается, это не достаточно позже, чтобы распределить только новую версию класса или интерфейса, который содержит определение флага. Изменение к значению флага, поэтому, не двоичный файл, совместимый с существующими ранее двоичными файлами (§13.4.9). (Есть другие причины такой несовместимости также, такие как использование констант в case метки в switch операторы; см. §13.4.9.)

Содержание | Предыдущий | Следующий | Индекс

Спецификация языка Java Третий Выпуск

Авторское право © 1996-2005 Sun Microsystems, Inc. Все права защищены
Пожалуйста, отправьте любые комментарии или исправления через нашу форму обратной связи