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

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

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

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

Следующий грамматический маневр объясняется необходимостью обойти знакомую проблему “обособленного else” (§ 14.4).

Операторы, которые будут знакомы программирующим на языке C и C++, это пустой (§ 14.5), помеченный (§ 14.6), выражение (§ 14.7), if (§14.8), switch (§14.9), while (§14.10), do (§14.11), for (§14.12), break (§14.13), continue (§14.14) и return (§14.15).

В отличие от Cи и Cи++, язык Ява не имеет оператора goto. Однако, операторы break и continue расширены в языке Ява до того, чтобы им разрешено упоминать метки операторов.

Операторы языка Ява, которых нет в языке C, - throw (§14.16), synchronized (§14.17) и try (§14.18).

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

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

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

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

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

Термины " завершен нормально "и" завершен преждевременно " также представляют собой оценку выражений (§ 15.5). Единственная причина, когда выражение может быть завершенным преждевременно, - это сгенерированное исключение из-за throw с данным значением (§ 14.16) или исключение времени выполнения, или ошибка (§11, §15.5).

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

Block:

	{ BlockStatementsopt }

BlockStatements:

	BlockStatement

	BlockStatements BlockStatement

BlockStatement:

	LocalVariableDeclarationStatement

	Statement

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

Операторы описания локальной переменной, представляют собой одно или более имен локальных переменных.

LocalVariableDeclarationStatement:

	LocalVariableDeclaration ;

LocalVariableDeclaration:

	Type VariableDeclarators

Далее идет повторение из §8.3 для того, чтобы сделать представление более понятным:

VariableDeclarators:

	VariableDeclarator

	VariableDeclarators , VariableDeclarator

VariableDeclarator:

	VariableDeclaratorId

	VariableDeclaratorId = VariableInitializer

VariableDeclaratorId:

	Identifier

	VariableDeclaratorId [ ]

VariableInitializer:

	Expression

	ArrayInitializer

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

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

Локальная переменная не может повторно упоминаться, используясь квалифицированным именем (§ 6.6), только простым именем.

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

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

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

потому что локальная переменная x определена (§ 16) прежде, чем использована. Печатается:

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

Инициализатор для three может правильно обратиться к переменной two, объявленной ранее в описателе, и вызов метода на следующей линии может правильно обратиться к переменной three, объявленный ранее в блоке.

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

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

Это ограничение помогает обнаруживать ошибки, поиск которых в другом случае был бы непрост. (Подобное ограничение на сокрытие членов класса локальными переменными оценено как непрактичное, потому что добавление члена в суперкласс могло бы привести к необходимости переименовывать локальные переменные подклассов.)

С другой стороны, локальные переменные с тем же самым именем могут быть объявлены в двух отдельных блоках или операторах 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

Если имя, объявленное как локальная переменная уже объявлено как поле или имя типа, тогда внешнее объявление скрывается областью видимости локальной переменной. Поле или имя типа по-прежнему почти всегда могут быть доступными (§6.8), употребляя нужное имя ограниченного использования. Например, ключевое слово this может использоваться для доступа к скрытому полю x, применяя форму this.x. На самом деле, эта форма записи типична для конструкторов (§8.6):

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

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

Оператор объявления локальной переменной - выполнимый оператор. Он выполняется каждый раз, операторы объявления обрабатываются в порядке слева направо. Если объявление имеет выражение инициализации, то выражение вычисляется и его значение присваивается переменной. Если объявление не имеет выражения инициализации, тогда Ява-компилятор должен показать, используя точный алгоритм, данный в §16, что каждой ссылке на переменную обязательно предшествует присваивание переменной. Если дело обстоит иначе, тогда происходит ошибка времени компиляции.

Как в Cи и Cи ++, в языке Ява оператор if испытывает так называемую "обособленную else проблему, " проиллюстрированную этим нерационально-форматированным примером:

if (door.isOpen())
	if (resident.isVisible())
		resident.greet("Hello!");
else door.bell.ring();								// "обособленное else"

Проблема состоит в том, что и внешний оператор if и внутренний оператор if могли бы, очевидно, иметь свое предложение else. В этом примере, каждый мог бы предположить, что программист намеревался отнести предложение else ко внешнему оператору if. Язык Ява , подобно Cи и Cи++ и многим языкам, созданным прежде, условно устанавливает, что предложение else относится к самому внутреннему оператору if, которому оно могло бы принадлежать. Это правило зафиксировано в следующей грамматике:

Statement:

	StatementWithoutTrailingSubstatement

	LabeledStatement

	IfThenStatement

	IfThenElseStatement

	WhileStatement

	ForStatement

StatementNoShortIf:

	StatementWithoutTrailingSubstatement

	LabeledStatementNoShortIf

	IfThenElseStatementNoShortIf

	WhileStatementNoShortIf

	ForStatementNoShortIf

StatementWithoutTrailingSubstatement:

	Block

	EmptyStatement

	ExpressionStatement

	SwitchStatement

	DoStatement

	BreakStatement

	ContinueStatement

	ReturnStatement

	SynchronizedStatement

	ThrowStatement

	TryStatement

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

IfThenStatement:

	if ( Expression ) Statement

IfThenElseStatement:

	if ( Expression ) StatementNoShortIf else Statement

IfThenElseStatementNoShortIf:

	if ( Expression ) StatementNoShortIf else StatementNoShortIf

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

Операторы могут иметь префикс label(метка).

LabeledStatement:

	Identifier : Statement

LabeledStatementNoShortIf:

	Identifier : StatementNoShortIf

Identifier объявляется для того, чтобы стать меткой содержащегося Statement.

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

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

идентификатора в качестве локальной переменной или в качестве параметра обработчика исключительной ситуации (§14.18) не скрывает метку оператора с тем же самым именем.

Помеченный оператор исполняется, немедленно выполняя содержащийся Statement. Если оператор помечен Identifier, и содержащийся Statement завершается преждевременно из-за оператора break с тем же самым Identifier, тогда помеченный оператор завершается обычным образом. Во всех других случаях преждевременного завершения оператора, помеченный оператор завершается преждевременно по той же самой причине.

Некоторые виды выражений могут использоваться как операторы, сопровождаемые точкой с запятой:

ExpressionStatement:

	StatementExpression ;

StatementExpression:

	Assignment

	PreIncrementExpression

	PreDecrementExpression

	PostIncrementExpression

	PostDecrementExpression

	MethodInvocation

	ClassInstanceCreationExpression

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

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

(void) ... ;	             // Это идиоматическое выражение применимо к Cи, но не к Ява!

не действует в языке Ява. С другой стороны, Ява позволяет все наиболее полезные виды выражений в операторах-выражениях и не требует вызова метода, используемого как оператор-выражение для того, чтобы вызвать void метод, так что такой прием практически никогда не нужен. Если же он необходим, то либо оператор присваивания (§15.25), либо оператор объявления локальной переменной (§14.3) могут быть использованы вместо него.

Оператор if позволяет условное выполнение оператора или условный выбор двух операторов, выполняя один или другой, но не оба сразу.

IfThenStatement:

	if ( Expression ) Statement

IfThenElseStatement:

	if ( Expression ) StatementNoShortIf else Statement

IfThenElseStatementNoShortIf:

	if ( Expression ) StatementNoShortIf else StatementNoShortIf

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

Оператор if-then начинается с вычисления Expression. Если вычисление Expression по некоторым причинам завершается преждевременно, то оператор if-then завершается преждевременно по той же самой причине. Иначе, выполнение продолжается, делая выбор, основанный на значении Expression:

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

Оператор if-then-else начинается с вычисления Expression. Если вычисление Expression по некоторой причине завершается преждевременно, тогда оператор if-then-else завершается преждевременно по той же самой причине. Иначе, выполнение продолжается, делая выбор, основанный на значении Expression:

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

Оператор switch передает управление одному из нескольких операторов в зависимости от значения выражения.

SwitchStatement:

	switch ( Expression ) SwitchBlock

SwitchBlock:

	{ SwitchBlockStatementGroupsopt SwitchLabelsopt }

SwitchBlockStatementGroups:

	SwitchBlockStatementGroup

	SwitchBlockStatementGroups SwitchBlockStatementGroup

SwitchBlockStatementGroup:

	SwitchLabels BlockStatements

SwitchLabels:

	SwitchLabel

	SwitchLabels SwitchLabel

SwitchLabel:

	case ConstantExpression :

	default :

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

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

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

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

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

где n-положительное число. Приём, показанный ниже, может использоваться в Cи или Cи++ для того, чтобы развернуть цикл, но он не действует в языке Ява:

int q = (n+7)/8;
switch (n%8) {
case 0:			do {		foo();				// Великая проделка Си, Том,
case 7:					foo();				// но не имеющая силы в Ява.
case 6:					foo();
case 5:					foo();
case 4:					foo();
case 3:					foo();
case 2:					foo();
case 1:					foo();
			} while (--q >= 0);
}

Когда выполняется оператор switch, вычисляется первое Expression. Если вычисление Expression по некоторой причине завершается преждевременно, то оператор switch завершается преждевременно по той же самой причине. Иначе, выполнение продолжается сравнением значения Expression с каждой константой case. В этом случае существует выбор:

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

Если какой-нибудь оператор непосредственно содержащийся в теле Block оператора switch завершается преждевременно, то он обрабатывается следующим образом:

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

Как в Cи и Cи++, в языке Ява при выполнении операторов в switch-блоке происходит "падение сквозь метки". Например, программа:

class Toomany {

	static void howMany(int k) {
		switch (k) {
		case 1:			System.out.print("one ");
		case 2:			System.out.print("too ");
		case 3:			System.out.println("many");
		}
	}


	public static void main(String[] args) {
		howMany(3);
		howMany(2);
		howMany(1);
	}

}

содержит switch-блок, в котором код для каждого случая продолжается в коде для следующего случая. В результате, программа печатает:

many
too many
one too many

В случае, когда “падение сквозь метки” не происходит, должен использоваться оператор break, как показано в этом примере:

class Twomany {

	static void howMany(int k) {
		switch (k) {
		case 1:			System.out.println("one");
					break;					// выход из switch
		case 2:			System.out.println("two");
					break;					// выход из switch
		case 3:			System.out.println("many");
					break;					// ненужный, но хороший стиль
		}
	}


	public static void main(String[] args) {
		howMany(1);
		howMany(2);
		howMany(3);
	}

}

one
two
many

Оператор while неоднократно выполняет Expression и Statement, пока значение Expression - не false.

WhileStatement:

	while ( Expression ) Statement

WhileStatementNoShortIf:

	while ( Expression ) StatementNoShortIf

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

Оператор while начинается с вычисления Expression. Если вычисление Expression по некоторой причине завершается преждевременно, оператор while завершается преждевременно по той же самой причине. Иначе, выполнение продолжается, делая выбор, основанный на значении Expression:

• Если значение- true, тогда содержащийся Statement выполняется. В этом случае имеется выбор:

• Если выполнение Statement завершается нормально, тогда весь оператор while приводится в исполнение снова, начиная дальнейшее вычисление Expression.
• Если выполнение Statement завершается преждевременно, смотрите ниже §14.10.1.
• Если значение Выражения - false, то дальнейшее действие не выполняется и оператор while завершается нормально.

Если значение Expression - false, то в первый раз оно вычисляется, а затем Statement не выполняется.

Преждевременное завершение содержащегося Statement обрабатывается следующим образом:

• Если выполнение Statement завершается преждевременно из-за оператора break без метки, то дальнейшее действие не выполняется, и оператор while завершается нормально.

• Если выполнение Statement завершается преждевременно из-за оператора continue без метки, тогда весь оператор while выполняется снова.
• Если выполнение Statement завершается преждевременно из-за оператора continue c меткой L, тогда имеется выбор:

• Если выполнение Statement завершается преждевременно по любой другой причине, то оператор while завершается преждевременно по той же самой причине. Заметим, что случай преждевременного завершения из-за оператора break с меткой обрабатывается в соответствии с общим правилом для помеченных операторов (§14.6).

Оператор do неоднократно выполняет Statement и Expression, пока значение Expression - не false.

DoStatement:

	do Statement while ( Expression ) ;

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

Оператор do начинается с вычисления Statement. Далее существует несколько вариантов:

• Если выполнение Statement завершается нормально, тогда Expression вычисляется. Если вычисление Expression завершается преждевременно по некоторой причине, то оператор do завершается преждевременно по той же самой причине. Иначе, существует несколько вариантов, основанных на значении Expression:

• Если значение- true, тогда весь оператор do выполняется снова.
• Если значение- false, тогда дальнейшее действие не выполняется, и оператор do завершается нормально.
• Если выполнение Statement завершается преждевременно, смотрите ниже §14.11.1.

При выполнении оператора do всегда, по крайней мере один раз, выполняется содержащийся Statement.

Преждевременное завершение содержащегося Statement обрабатывается следующим образом:

• Если выполнение Statement завершается преждевременно из-за оператора break без метки, тогда дальнейшее действие не выполняется, и оператор do завершается нормально.
• Если выполнение Statement завершается преждевременно из-за оператора continue без метки, тогда вычисляется Statement. Далее существует выбор, основанный на значении Expression:

• Если значение- true, тогда весь оператор do выполняется снова.
• Если значение- false, тогда дальнейшее действие не выполняется, и оператор do завершается нормально.
• Если выполнение Statement завершается преждевременно из-за оператора continue с меткой L, тогда существует выбор:

• Если оператор do имеет метку L, тогда вычисляется Expression. Далее существует несколько вариантов:

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

Следующий код - первая возможная реализация метода toHexString (§20.7.14) класса Integer:

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

Так как должна быть сгенерирована по крайней мере одна цифра, оператор do - подходящая структура управления.

Оператор for выполняет некоторый код инициализации, затем неоднократно выполняет Expression, Statement и некоторый код обновления, пока значение Expression - не false.

ForStatement:

	for ( ForInitopt ; Expressionopt ; ForUpdateopt )

		Statement

ForStatementNoShortIf:

	for ( ForInitopt ; Expressionopt ; ForUpdateopt )

		StatementNoShortIf

ForInit:

	StatementExpressionList

	LocalVariableDeclaration

ForUpdate:

	StatementExpressionList

StatementExpressionList:

	StatementExpression

	StatementExpressionList , StatementExpression

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

Оператор for начинается с выполнения кода ForInit:

• Если код ForInit - это список операторов-выражений (§14.7), то выражения вычисляются в последовательности слева направо; их значения, если таковые имеются, отбрасываются. Если вычисление какого-нибудь выражения по некоторой причине завершается преждевременно, то оператор for завершается преждевременно по той же самой причине; любые ForInit оператор-выражения справа от того, который завершен преждевременно, не вычисляются.
• Если код ForInit - объявление локальной переменной, то он выполняется так, как если бы он был оператором объявления локальной переменной (§14.3) , появившейся в блоке. В этом случае, область видимости объявленной локальной переменной - это ее собственный инициализатор и любые дальнейшие объявления в ForInit части, плюс Expression, ForUpdate и Statement, содержащийся в операторе for. Если выполнение объявления локальной переменной по какой-то причине завершается преждевременно, то оператор for завершается преждевременно по той же самой причине.
• Если часть ForInit отсутствует, то никакое действие не выполняется.

Далее, итеративный шаг for выполняется следующим образом:

• Если Expression присутствует, то оно вычисляется и, если вычисление Expression завершается преждевременно, оператор for завершается преждевременно по той же самой причине. Иначе, имеется выбор, основанный на присутствии или отсутствии Expression и на значении Expression, если Expression присутствует:

• Если Expression отсутствует, или присутствует и значение при его вычислении- true, тогда содержащийся Statement выполняется. Далее существует выбор:

• Если выполнение Statement завершается нормально, тогда следующие два шага выполняются в последовательности:

• Во-первых, если ForUpdate часть присутствует, выражения вычисляются слева направо; их значения, если не нужны, отбрасываются. Если вычисление какого-нибудь выражения завершается преждевременно по некоторой причине, то оператор for завершается преждевременно по той же самой причине; любые ForUpdate оператор-выражения справа от того, который завершен преждевременно, не вычисляются. Если ForUpdate часть отсутствует, то никакое действие не выполняется.
• Во-вторых, выполняется другой итеративный шаг for.
• Если выполнение Statement завершается преждевременно, то смотрите ниже §14.12.3.
• Если Expression присутствует и значение при его вычислении - false, то никакое действие не выполняется и оператор for завершается нормально.

Если значение Expression - false, то сначала оно вычисляется, а далее Statement не выполняется.

Если Expression отсутствует, тогда оператор for может завершаться нормально единственным путем, т.е. при помощи оператора break.

Преждевременное завершение содержащегося Statement обрабатывается следующим образом:

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

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

• Если оператор for имеет метку L, тогда следующие два шага выполняются в последовательности:

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

Оператор break передает управление наружу оператора, внутри которого он находится.

BreakStatement:

	break Identifieropt ;

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

Оператор break с меткой Identifier пытается передать управление помеченному оператору, внутри которого он находится (§14.6), который содержит тот же самый Identifier в качестве метки; этот оператор, который называется цель прерывания, затем немедленно завершается обычным образом. В этом случае, цель прерывания не должна быть while, do, for или switch оператором. Чтобы быть точным, оператор break с меткой Identifier всегда завершается преждевременно, причина в операторе break с меткой Identifier. Если оператор break содержится вне оператора с меткой Identifier, то происходит ошибка времени компиляции.

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

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

В следующем примере, математический граф представлен массивом из массивов. Граф состоит из множества вершин и множества ребер; каждое ребро является стрелкой, которая направлена от некоторой вершины до другой вершины, или от некоторой вершины до этой же вершины. В этом примере предполагается, что нет никаких лишних ребер; то есть для любых двух вершин P и Q, где Q может совпадать с P, существует максимум одно ребро от P до Q. Вершины представлены целыми числами, и есть ребро от вершины i до вершины edges[i][j] для каждого i и 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;
					}

//Никакое ребро не

					newedges[k] = edges[k];
					break edgelist;
				}//search

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

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

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

made it!

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

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)

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

while (false) { x=3; }

if (false) { x=3; }

static final boolean DEBUG = false;

if (DEBUG) { x=3; }