спецификации, руководства, описания, API

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

ГЛАВА 14

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

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

Некоторые операторы содержат другие операторы как часть их структуры; такие другие операторы являются подоператорами оператора. Мы говорим, что оператор 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++, Java имеет нет goto оператор. Однако, break и continue операторы расширяются в Java, чтобы позволить им упоминать метки оператора.

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

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

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

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

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

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

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

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

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

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

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

14.2 Блоки

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

Block:

	{ BlockStatements_opt }

BlockStatements:

	BlockStatement

	BlockStatements BlockStatement

BlockStatement:

	LocalVariableDeclarationStatement

	Statement

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

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

Оператор объявления локальной переменной объявляет одно или более имен локальной переменной.

LocalVariableDeclarationStatement:

	LocalVariableDeclaration ;

LocalVariableDeclaration:

	Type VariableDeclarators

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

VariableDeclarators:

	VariableDeclarator

	VariableDeclarators , VariableDeclarator

VariableDeclarator:

	VariableDeclaratorId

	VariableDeclaratorId = VariableInitializer

VariableDeclaratorId:

	Identifier

	VariableDeclaratorId [ ]

VariableInitializer:

	Expression

	ArrayInitializer

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

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

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

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

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

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

эквивалентно серии объявлений:


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

Скобки позволяются в операторах объявления как намек на традицию C и C++. Общее правило, однако, также означает что объявление локальной переменной:

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

эквивалентно серии объявлений:


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

Мы не рекомендуем такую "смешанную нотацию" для объявлений массива.

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

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

Локальная переменная не может быть отнесена в использование полностью определенного имени (§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) прежде, чем он будет использоваться. Это печатает:

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


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 объявленный ранее в блоке.

Контекст локальной переменной объявляется в a 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

14.3.3 Сокрытие Имен Локальными переменными

Если имя, объявленное как локальная переменная, уже объявляется как имя поля или имя типа, то то внешнее описание скрывается всюду по контексту локальной переменной. Имя поля или имя типа могут почти всегда (§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;
	}
}

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

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

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

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

14.4 Операторы

Есть много видов операторов на языке Java. Большинство соответствует операторам в C и языках C++, но некоторые уникальны для Java.

Как в C и C++, Java if оператор страдает от так называемого "свисания 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

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 оператор") и те, которые определенно не делают. Только операторы, которые определенно не заканчиваются в коротком if оператор может появиться как непосредственный подоператор перед ключевым словом else в if оператор, который действительно имеет else пункт. Это простое правило предотвращает "свисание else"проблема. Поведение при выполнении оператора с "нет короткий if"ограничение идентично поведению при выполнении того же самого вида оператора без "нет короткий if"ограничение; различие оттягивается просто, чтобы разрешить синтаксическую трудность.

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

Пустой оператор ничего не делает.

EmptyStatement:

	;

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

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

У операторов могут быть префиксы метки.

LabeledStatement:

	Identifier : Statement

LabeledStatementNoShortIf:

	Identifier : StatementNoShortIf

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

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

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

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

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

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

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

ExpressionStatement:

	StatementExpression ;

StatementExpression:

	Assignment

	PreIncrementExpression

	PreDecrementExpression

	PostIncrementExpression

	PostDecrementExpression

	MethodInvocation

	ClassInstanceCreationExpression

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

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

(void) ... ;								// This idiom belongs to C, not to Java!

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

14.8 `if` Оператор

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

IfThenStatement:

	if ( Expression ) Statement

IfThenElseStatement:

	if ( Expression ) StatementNoShortIf else Statement

IfThenElseStatementNoShortIf:

	if ( Expression ) StatementNoShortIf else StatementNoShortIf

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

14.8.1 `if-then` Оператор

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

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

14.8.2 `if-then-else` Оператор

if-then-else оператор выполняется первой оценкой Выражения. Если оценка Выражения завершается резко по некоторым причинам, то if- then-else оператор завершается резко по той же самой причине. Иначе, выполнение продолжается, делая выбор, основанный на получающемся значении:

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

14.9 `switch` Оператор

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

SwitchStatement:

	switch ( Expression ) SwitchBlock

SwitchBlock:

	{ SwitchBlockStatementGroups_opt SwitchLabels_opt }

SwitchBlockStatementGroups:

	SwitchBlockStatementGroup

	SwitchBlockStatementGroups SwitchBlockStatementGroup

SwitchBlockStatementGroup:

	SwitchLabels BlockStatements

SwitchLabels:

	SwitchLabel

	SwitchLabels SwitchLabel

SwitchLabel:

	case ConstantExpression :

	default :

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

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

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

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

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

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

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


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

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

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

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

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

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

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

Как в C и C++, выполнение операторов в блоке переключателя "проваливается метки" в Java. Например, программа:


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

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


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.10 `while` Оператор

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

WhileStatement:

	while ( Expression ) Statement

WhileStatementNoShortIf:

	while ( Expression ) StatementNoShortIf

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

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

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

Если значение Выражения false в первый раз, когда это оценивается, тогда Оператор не выполняется.

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

Резкое завершение содержавшего Оператора обрабатывается следующим способом:

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

14.11 `do` Оператор

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

DoStatement:

	do Statement while ( Expression ) ;

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

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

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

Выполнение a do оператор всегда выполняет содержавший Оператор, по крайней мере, однажды.

14.11.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.6).

14.11.2 Пример `do` оператор

Следующий код является одной возможной реализацией 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 оператор является соответствующей управляющей структурой.

14.12 `for` Оператор

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

ForStatement:

	for ( ForInit_opt ; Expression_opt ; ForUpdate_opt )

		Statement

ForStatementNoShortIf:

	for ( ForInit_opt ; Expression_opt ; ForUpdate_opt )

		StatementNoShortIf

ForInit:

	StatementExpressionList

	LocalVariableDeclaration

ForUpdate:

	StatementExpressionList

StatementExpressionList:

	StatementExpression

	StatementExpressionList , StatementExpression

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

14.12.1 Инициализация `for` оператор

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

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

14.12.2 Итерация `for` оператор

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

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

Если значение Выражения false в первый раз, когда это оценивается, тогда Оператор не выполняется.

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

14.12.3 Резкое Завершение `for` оператор

Резкое завершение содержавшего Оператора обрабатывается следующим способом:

Если выполнение Оператора завершается резко из-за 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.6).

14.13 `break` Оператор

Оператор завершения передает управление из оператора включения.

BreakStatement:

	break Identifier_opt ;

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

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

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

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

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

Отметьте использование двух меток оператора, edgelist и search, и использование break операторы. Это позволяет код, который копирует список, опуская один край, чтобы быть совместно использованным двумя отдельными тестами, тестом для края от узла i к узлу j, и тесту для края от узла j к узлу i.

14.14 `continue` Оператор

A continue оператор может произойти только в a while, do, или for оператор; операторы этих трех видов вызывают операторами цикла. Управление передает к точке продолжения цикла оператора цикла.

ContinueStatement:

	continue Identifier_opt ;

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

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

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

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

Предыдущие описания говорят "попытки передать управление", а не только "управление передачами" потому что, если есть кто-либо try операторы (§14.18) в пределах продолжать цели, чей 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.15 `return` Оператор

A return оператор возвращает управление invoker метода (§8.4, §15.11) или конструктор (§8.6, §15.8).

ReturnStatement:

	return Expression_opt ;

A return оператор без Выражения должен содержаться в теле метода, который объявляется, используя ключевое слово void, не возвратить любое значение (§8.4), или в теле конструктора (§8.6). Ошибка времени компиляции происходит если a return оператор появляется в пределах статического инициализатора (§8.5). A return оператор без Выражения пытается передать управление invoker метода или конструктора, который содержит это. Быть точным, a return оператор без Выражения всегда завершается резко, причина, являющаяся a return без значения.

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

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

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

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

14.16 `throw` Оператор

A throw оператор заставляет исключение (§11) быть брошенным. Результатом является непосредственная передача управления (§11.3), который может выйти из многократных операторов и многократного конструктора, статичного и полевые оценки инициализатора, и вызовы метода до a try оператор (§14.18) находится, который ловит брошенное значение. Если не такой try оператор находится, тогда выполнение потока (§17, §20.20), который выполнился throw завершается (§11.3) после вызова UncaughtException метод (§20.21.31) для группы потока, которой принадлежит поток.

ThrowStatement:

	throw Expression ;

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

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

A throw оператор сначала оценивает Выражение. Если оценка Выражения завершается резко по некоторым причинам, то throw завершается резко по этой причине. Если оценка Выражения обычно завершается, производя значение V, то throw оператор завершается резко, причина, являющаяся a throw со значением V.

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

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

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

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

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

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

14.17 `synchronized` Оператор

A synchronized оператор получает блокировку взаимного исключения (§17.13) от имени выполняющегося потока, выполняет блок, затем выпускает блокировку. В то время как выполняющемуся потоку принадлежит блокировка, никакой другой поток не может получить блокировку.

SynchronizedStatement:

	synchronized ( Expression ) Block

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

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

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

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

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

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

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


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

печатные издания:

made it!

Этот пример был бы мертвая блокировка, если единственному потоку не разрешили заблокировать блокировку не раз.

14.18 `try` оператор

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

TryStatement:

	try Block Catches

	try Block Catches_opt Finally

Catches:

	CatchClause

	Catches CatchClause

CatchClause:

	catch ( FormalParameter ) Block

Finally:

	finally Block

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

FormalParameter:

	Type VariableDeclaratorId

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

VariableDeclaratorId:

	Identifier

	VariableDeclaratorId [ ]

Блок сразу после ключевого слова try вызывается try блок try оператор. Блок сразу после ключевого слова finally вызывается finally блок try оператор.

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

Контекстом имени параметра исключения является Блок catch пункт. Имя параметра не может быть повторно объявлено как локальная переменная или параметр исключения в пределах Блока catch пункт; то есть, сокрытие имени параметра исключения не разрешается.

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

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

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

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

14.18.1 Выполнение `try-catch`

A try оператор без a finally блок выполняется первым выполнением try блок. Затем есть выбор:

Если выполнение 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 бросается методом blowUp. try-catch оператор в теле main имеет два catch пункты. Тип времени выполнения исключения BlewIt который не присваиваем переменной типа RuntimeException, но присваиваемо переменной типа BlewIt, таким образом, вывод примера:

BlewIt

14.18.2 Выполнение `try-catch-finally`

A try оператор с a finally блок выполняется первым выполнением try блок. Затем есть выбор:

Если выполнение 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)

NullPointerException (который является своего рода RuntimeException) это бросается методом blowUp не пойман try оператор в main, потому что a NullPointerException не присваиваемо переменной типа BlewIt. Это вызывает finally пункт тот, чтобы выполнить, после который выполнение потока main, то, который является единственным потоком тестовой программы, завершается из-за непойманного исключения (§20.21.31), который приводит к печати имени исключения и простого следа.

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

Это - ошибка времени компиляции, если оператор не может быть выполнен, потому что это недостижимо. Каждый компилятор Java должен выполнить консервативный анализ потоков, определенный здесь, чтобы удостовериться, что все операторы достижимы.

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


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

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

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

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

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

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

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

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

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

while

false

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

do

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

for

false

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.

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

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

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

while (false) { x=3; }

потому что оператор x=3; не достижимо; но поверхностно подобный случай:

if (false) { x=3; }

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

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

static final boolean DEBUG = false;

и затем запишите код, такой как:

if (DEBUG) { x=3; }

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

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

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

Спецификация языка Java (HTML, сгенерированный Блинчиком "сюзет" Pelouch 24 февраля 1998)
Авторское право © Sun Microsystems, Inc 1996 года. Все права защищены
Пожалуйста, отправьте любые комментарии или исправления к doug.kramer@sun.com

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

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

14.2 Блоки

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

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

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

14.3.3 Сокрытие Имен Локальными переменными

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

14.4 Операторы

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

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

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

14.8 if Оператор

14.8.1 if-then Оператор

14.8.2 if-then-else Оператор

14.9 switch Оператор

14.10 while Оператор

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

14.11 do Оператор

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

14.11.2 Пример do оператор

14.12 for Оператор

14.12.1 Инициализация for оператор

14.12.2 Итерация for оператор

14.12.3 Резкое Завершение for оператор

14.13 break Оператор

14.14 continue Оператор

14.15 return Оператор

14.16 throw Оператор

14.17 synchronized Оператор

14.18 try оператор

14.18.1 Выполнение try-catch

14.18.2 Выполнение try-catch-finally

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

14.8 `if` Оператор

14.8.1 `if-then` Оператор

14.8.2 `if-then-else` Оператор

14.9 `switch` Оператор

14.10 `while` Оператор

14.11 `do` Оператор

14.11.2 Пример `do` оператор

14.12 `for` Оператор

14.12.1 Инициализация `for` оператор

14.12.2 Итерация `for` оператор

14.12.3 Резкое Завершение `for` оператор

14.13 `break` Оператор

14.14 `continue` Оператор

14.15 `return` Оператор

14.16 `throw` Оператор

14.17 `synchronized` Оператор

14.18 `try` оператор

14.18.1 Выполнение `try-catch`

14.18.2 Выполнение `try-catch-finally`