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

ГЛАВА 15

Выражения

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

Эта глава определяет значения выражений Java и правил для их оценки.

15.1 Оценка, Обозначение, и Результат

• Переменная (§4.5) (в C, это вызвали бы lvalue),
• Значение (§4.2, §4.3)
• Ничто (выражение, как говорят, void)

Выражение ничего не обозначает, если и только если это - вызов метода (§15.11), который вызывает метод, который не возвращает значение, то есть, объявленный метод void (§8.4). Такое выражение может использоваться только в качестве оператора выражения (§14.7), потому что любой контекст, в котором может появиться выражение, требует, чтобы выражение обозначило что-то. Оператор выражения, который является вызовом метода, может также вызвать метод, который приводит к результату; в этом случае значение, возвращенное методом, спокойно отбрасывается.

Каждое выражение происходит в объявлении некоторых (класс или интерфейс) тип, который объявляется: в полевом инициализаторе, в статическом инициализаторе, в объявлении конструктора, или в коде для метода.

15.2 Переменные как Значения

15.3 Тип Выражения

Значение выражения всегда является присвоением, совместимым (§5.2) с типом выражения, так же, как значение, сохраненное в переменной, является всегда совместимым с типом переменной. Другими словами значение выражения, тип которого является T, является всегда подходящим для присвоения на переменную типа T.

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

15.4 Выражения и Проверки на этапе выполнения

• Вызов метода (§15.11). Определенный метод используется для вызова o.m(...) выбирается основанный на методах, которые являются частью класса или интерфейса, который является типом o. Например методы, класс объекта, на который ссылается значение времени выполнения o участвует, потому что подкласс может переопределить определенный метод, уже объявленный в родительском классе так, чтобы этот метод переопределения был вызван. (Метод переопределения может или, возможно, не хочет далее вызывать переопределенный оригинал m метод.)
• instanceof оператор (§15.19.2). Выражение, тип которого является ссылочным типом, может быть протестировано, используя instanceof узнать, является ли класс объекта, на который ссылается значение времени выполнения выражения, присвоением, совместимым (§5.2) с некоторым другим ссылочным типом.
• Бросая (§5.4, §15.15). Класс объекта, на который ссылается значение времени выполнения выражения операнда, не мог бы быть совместимым с типом, определенным броском. Для ссылочных типов это может потребовать проверки на этапе выполнения, которая бросает ошибку, если класс объекта, на который ссылаются, как определено во время выполнения, не является присвоением, совместимым (§5.2) с целевым типом.
• Присвоение на компонент массива ссылочного типа (§10.10, §15.12, §15.25.1). Проверяющие тип правила позволяют тип S массива[] быть обработанным как подтип T[] если S является подтипом T, но это требует проверки на этапе выполнения на присвоение на армейский компонент, подобный проверке, выполняемой для броска.
• Обработка исключений (§14.18). Исключение поймано a catch пункт, только если класс брошенного объекта исключения instanceof тип формального параметра catch пункт.

• В броске, когда фактический класс объекта, на который ссылается значение выражения операнда, не является совместимым с целевым типом, определенным оператором броска (§5.4, §15.15); в этом случае a ClassCastException бросается.
• В присвоении на компонент массива ссылочного типа, когда фактический класс объекта, на который ссылается значение, которое будет присвоено, не является совместимым с фактическим компонентным типом времени выполнения массива (§10.10, §15.12, §15.25.1); в этом случае ArrayStoreException бросается.
• Когда исключение не поймано никем catch обработчик (§11.3); в этом случае поток управления, которое встретилось с исключением сначала, вызывает метод uncaughtException (§20.21.31) для его группы потока и затем завершается.

15.5 Нормальное и Резкое Завершение Оценки

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

Исключения на этапе выполнения бросаются предопределенными операторами следующим образом:

• Выражение создания экземпляра класса (§15.8), выражение создания массива (§15.9), или конкатенация строк operatior выражение (§15.17.1) бросает OutOfMemoryError если есть недостаточная доступная память.
• Выражение создания массива бросает ArrayNegativeSizeException если значение какого-либо выражения размерности является меньше чем нуль (§15.9).
• Доступ к полю (§15.10) бросает a NullPointerException если значение выражения ссылки на объект null.
• Выражение вызова метода (§15.11), который вызывает метод экземпляра броски a NullPointerException если целевая ссылка null.
• Доступ массива (§15.12) бросает a NullPointerException если значение ссылочного выражения массива null.
• Доступ массива (§15.12) бросает IndexOutOfBoundsException если значение индексного выражения массива отрицательно или больше чем или равно length из массива.
• Бросок (§15.15) бросает a ClassCastException если бросок, как находят, непозволителен во время выполнения.
• Целочисленное деление (§15.16.2) или целочисленный остаток (§15.16.3) оператор бросает ArithmeticException если значение правого выражения операнда является нулем.
• Присвоение на компонент массива ссылочного типа (§15.25.1) бросает ArrayStoreException когда значение, которое будет присвоено, не является совместимым с компонентным типом массива.

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

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

15.6 Порядок оценки

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

15.6.1 Оцените Левый Операнд Сначала

Таким образом:

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

9

Если оператор является составным оператором присваивания (§15.25.2), то оценка левого операнда включает и запоминание переменной, которую левый операнд обозначает и выборка и сохранение что значение переменной для использования в подразумеваемой работе объединения. Так, например, тестовая программа:

class Test {
	public static void main(String[] args) {
		int a = 9;
		a += (a = 3);									// first example
		System.out.println(a);
		int b = 9;
		b = b + (b = 3);									// second example
		System.out.println(b);
	}
}

12
12

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

Таким образом, тестовая программа:

class Test {

	public static void main(String[] args) {

		int j = 1;

		try {
			int i = forgetIt() / (j = 2);
		} catch (Exception e) {
			System.out.println(e);
			System.out.println("Now j = " + j);
		}
	}

	static int forgetIt() throws Exception {
		throw new Exception("I'm outta here!");
	}
}

java.lang.Exception: I'm outta here!
Now j = 1

15.6.2 Оцените Операнды перед Работой

Если бинарный оператор является целочисленным делением / (§15.16.2) или целочисленный остаток % (§15.16.3), тогда его выполнение может повысить ArithmeticException, но это исключение выдается только после того, как оба операнда бинарного оператора были оценены и только если эти оценки, завершаемые обычно.

Так, например, программа:

class Test {

	public static void main(String[] args) {
		int divisor = 0;
		try {
			int i = 1 / (divisor * loseBig());
		} catch (Exception e) {
			System.out.println(e);
		}
	}


	static int loseBig() throws Exception {
		throw new Exception("Shuffle off to Buffalo!");
	}

}

java.lang.Exception: Shuffle off to Buffalo!

java.lang.ArithmeticException: / by zero

15.6.3 Круглые скобки Отношений оценки и Приоритет

В случае вычислений с плавающей точкой это правило применяет также для бесконечности и не-числа (НЭН) значения. Например, !(x<y) возможно, не переписывается как x>=y, потому что у этих выражений есть различные значения если также x или y НЭН.

Определенно, вычисления с плавающей точкой, которые, кажется, математически ассоциативны, вряд ли будут в вычислительном отношении ассоциативны. Такие вычисления не должны быть наивно переупорядочены. Например, это не корректно для компилятора Java, чтобы переписать 4.0*x*0.5 как 2.0*x; в то время как округление, оказывается, не проблема здесь, есть большие значения x для которого первое выражение производит бесконечность (из-за переполнения), но второе выражение приводит к конечному результату.

Так, например, тестовая программа:

class Test {

	public static void main(String[] args) {
		double d = 8e+307;
		System.out.println(4.0 * d * 0.5);
		System.out.println(2.0 * d);
	}
}

Infinity
1.6e+308

Напротив, целочисленное дополнение и умножение доказуемо ассоциативны в Java; например a+b+c, где a, b, и c локальные переменные (это предположение упрощения избегает проблем, включающих многократные потоки и volatile переменные), будет всегда производить тот же самый ответ, оцененный ли как (a+b)+c или a+(b+c); если выражение b+c происходит поблизости в коде, умный компилятор может быть в состоянии использовать это общее подвыражение.

15.6.4 Списки параметров Оцениваются Слева направо

Таким образом:

class Test {

	public static void main(String[] args) {
		String s = "going, ";
		print3(s, s, s = "gone");
	}

	static void print3(String a, String b, String c) {
		System.out.println(a + b + c);
	}
}

going, going, gone

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

Таким образом, пример:

class Test {
	static int id;
	public static void main(String[] args) {
		try {
			test(id = 1, oops(), id = 3);
		} catch (Exception e) {
			System.out.println(e + ", id=" + id);
		}
	}

	static int oops() throws Exception {
		throw new Exception("oops");
	}

	static int test(int a, int b, int c) {
		return a + b + c;
	}

}

java.lang.Exception: oops, id=1

15.6.5 Порядок оценки на Другие Выражения

• выражения создания экземпляра класса (§15.8.1)
• выражения создания массива (§15.9.1)
• выражения вызова метода (§15.11.4)
• выражения доступа массива (§15.12.1)
• присвоения, включающие компоненты массива (§15.25)

15.7 Основные Выражения

Primary:

	PrimaryNoNewArray

	ArrayCreationExpression

PrimaryNoNewArray:

	Literal

	this

	( Expression )

	ClassInstanceCreationExpression

	FieldAccess

	MethodInvocation

	ArrayAccess

Технические причины имеют отношение к разрешению слева направо анализирующий программ Java с только предвидением с одним маркером. Рассмотрите выражения (z[3]) и (z[]). Первым является заключенный в скобки доступ массива (§15.12), и вторым является запуск броска (§15.15). В точке, которая предварительный символ [, слева направо синтаксический анализ уменьшит z к нетерминальному Имени. В контексте броска мы предпочитаем не должными быть уменьшать имя к Основному устройству, но если бы Имя было одной из альтернатив для Основного, то мы не могли сказать, сделать ли сокращение (то есть, мы не могли бы определить, окажется ли текущая ситуация, будет заключенным в скобки доступом массива или броском), не предусматривая два маркера, к маркеру после [. Грамматика Java, представленная здесь, избегает проблемы, сохраняя Имя и Основной отдельный и позволяя любому войти определенные другие правила синтаксиса (те для MethodInvocation, ArrayAccess, PostfixExpression, но не для FieldAccess, потому что это покрывается по имени). Эта стратегия эффективно задерживает вопрос того, должно ли Имя быть обработано как Основное устройство, пока больше контекста не может быть исследовано. (Другие проблемы остаются с выражениями броска; см. §19.1.5.)

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

new int[3][3]

(new int[3])[3]

15.7.1 Литералы

Следующее производство от §3.10 повторяется здесь для удобства:

Literal:

	IntegerLiteral

	FloatingPointLiteral

	BooleanLiteral

	CharacterLiteral

	StringLiteral

	NullLiteral

• Тип целочисленного литерала, который заканчивается L или l long; тип любого другого целочисленного литерала int.
• Тип литерала с плавающей точкой, который заканчивается F или f float; тип любого другого литерала с плавающей точкой double.
• Тип булева литерала boolean.
• Тип символьного литерала char.
• Тип строкового литерала String.
• Тип нулевого литерала null нулевой тип; его значение является нулевой ссылкой.

15.7.2 this

Когда использующийся в качестве основного выражения, ключевого слова this обозначает значение, которое является ссылкой на объект, для которого метод экземпляра был вызван (§15.11), или к создаваемому объекту. Тип this класс C в пределах который ключевое слово this происходит. Во время выполнения класс фактического упомянутого объекта может быть классом C или любым подклассом C.

В примере:

class IntVector {
	int[] v;
	boolean equals(IntVector other) {
		if (this == other)
			return true;
		if (v.length != other.v.length)
			return false;
		for (int i = 0; i < v.length; i++)
			if (v[i] != other.v[i])
				return false;
		return true;
	}

}

Ключевое слово this также используется в специальном явном операторе вызова конструктора, который может появиться в начале тела конструктора (§8.6.5).

15.7.3 Заключенные в скобки Выражения

15.8 Выражения Создания Экземпляра класса

ClassInstanceCreationExpression:

	new ClassType ( ArgumentListopt )

ArgumentList:

	Expression

	ArgumentList , Expression

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

15.8.1 Оценка времени выполнения Выражений Создания Экземпляра Класса

Во-первых, место выделяется для нового экземпляра класса. Если есть недостаточное пространство, чтобы выделить объект, оценка выражения создания экземпляра класса завершается резко, бросая OutOfMemoryError (§15.8.2).

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

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

Затем, выбранный конструктор указанного типа класса вызывается. Это приводит к вызову по крайней мере одного конструктора для каждого суперкласса типа класса. Этот процесс может быть направлен явными операторами вызова конструктора (§8.6) и описывается подробно в §12.5.

Значение выражения создания экземпляра класса является ссылкой на недавно создаваемый объект указанного класса. Каждый раз, когда выражение оценивается, новый объект создается.

15.8.2 Пример: Порядок Оценки и Обнаружение Из памяти

Так, например, тестовая программа:

class List {
	int value;
	List next;
	static List head = new List(0);
	List(int n) { value = n; next = head; head = this; }
}

class Test {
	public static void main(String[] args) {
		int id = 0, oldid = 0;
		try {
			for (;;) {
				++id;
				new List(oldid = id);
			}
		} catch (Error e) {
			System.out.println(e + ", " + (oldid==id));
		}
	}
}

java.lang.OutOfMemoryError: List, false

Сравните это с обработкой выражений создания массива (§15.9), для которого условие из памяти обнаруживается после оценки выражений размерности (§15.9.3).

15.9 Выражения Создания массива

ArrayCreationExpression:

	new PrimitiveType DimExprs Dimsopt

	new TypeName DimExprs Dimsopt

DimExprs:

	DimExpr

	DimExprs DimExpr

DimExpr:

	[ Expression ]

Dims:

	[ ]

	Dims [ ]

Тип выражения создания является типом массива, который может обозначенный копией выражения создания от который new ключевое слово и каждое выражение DimExpr были удалены; например, тип выражения создания:

new double[3][3][]

double[][][]

15.9.1 Оценка времени выполнения Выражений Создания Массива

Во-первых, выражения размерности оцениваются, слева направо. Если какое-либо из вычислений выражения завершается резко, выражения направо от этого не оцениваются.

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

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

Затем, если единственный DimExpr появляется, одномерный массив создается из указанной длины, и каждый компонент массива инициализируется к его стандартному значению по умолчанию (§4.5.4).

Если выражение создания массива содержит выражения DimExpr N, то оно эффективно выполняет ряд вложенных циклов глубины, чтобы создать подразумеваемые массивы массивов. Например, объявление:

float[][] matrix = new float[3][3];

float[][] matrix = new float[3][];
for (int d = 0; d < matrix.length; d++)
	matrix[d] = new float[3];

Age[][][][][] Aquarius = new Age[6][10][8][12][];

Age[][][][][] Aquarius = new Age[6][][][][];
for (int d1 = 0; d1 < Aquarius.length; d1++) {
	Aquarius[d1] = new Age[8][][][];
	for (int d2 = 0; d2 < Aquarius[d1].length; d2++) {
		Aquarius[d1][d2] = new Age[10][][];
		for (int d3 = 0; d3 < Aquarius[d1][d2].length; d3++) {
			Aquarius[d1][d2][d3] = new Age[12][];
		}
	}
}

Age[] Hair = { new Age("quartz"), new Age("topaz") };
Aquarius[1][9][6][9] = Hair;

float triang[][] = new float[100][];
for (int i = 0; i < triang.length; i++)
	triang[i] = new float[i+1];

15.9.2 Пример: Порядок Оценки Создания Массива

Таким образом:

class Test {
	public static void main(String[] args) {
		int i = 4;
		int ia[][] = new int[i][i=3];
		System.out.println(
			"[" + ia.length + "," + ia[0].length + "]");
	}
}

[4,3]

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

class Test {

	public static void main(String[] args) {
		int[][] a = { { 00, 01 }, { 10, 11 } };
		int i = 99;
		try {
			a[val()][i = 1]++;
		} catch (Exception e) {
			System.out.println(e + ", i=" + i);
		}
	}

	static int val() throws Exception {
		throw new Exception("unimplemented");
	}

}

java.lang.Exception: unimplemented, i=99

15.9.3 Пример: Создание Массива и Обнаружение Из памяти

Так, например, тестовая программа:

class Test {
	public static void main(String[] args) {
		int len = 0, oldlen = 0;
		Object[] a = new Object[0];
		try {
			for (;;) {
				++len;
				Object[] temp = new Object[oldlen = len];
				temp[0] = a;
				a = temp;
			}
		} catch (Error e) {
			System.out.println(e + ", " + (oldlen==len));
		}
	}
}

java.lang.OutOfMemoryError, true

Сравните это с выражениями создания экземпляра класса (§15.8), которые обнаруживают условие из памяти прежде, чем оценить выражения параметра (§15.8.2).

15.10 Выражений Доступа к полю

FieldAccess:

	Primary . Identifier

	super . Identifier

15.10.1 Доступ к полю Используя Основное устройство

• Если идентификатор называет несколько доступных задействованных полей типа T, то доступ к полю неоднозначен, и ошибка времени компиляции происходит.
• Если идентификатор не называет доступное задействованное поле типа T, то доступ к полю неопределен, и ошибка времени компиляции происходит.
• Иначе, идентификатор называет единственное доступное задействованное поле типа T, и тип выражения доступа к полю является объявленным типом поля. Во время выполнения результат выражения доступа к полю вычисляется следующим образом:
  • Если поле static:
    • Если поле final, тогда результатом является значение указанной переменной класса в классе, или взаимодействуйте через интерфейс, который является типом Основного выражения.
    • Если поле не final, тогда результатом является переменная, а именно, указанная переменная класса в классе, который является типом Основного выражения.
  • Если поле не static:
    • Если значение Основного устройства null, тогда a NullPointerException бросается.
    • Если поле final, тогда результатом является значение указанной переменной экземпляра в объекте, на который ссылается значение Основного устройства.
    • Если поле не final, тогда результатом является переменная, а именно, указанная переменная экземпляра в объекте, на который ссылается значение Основного устройства.

Таким образом, пример:

class S { int x = 0; }
class T extends S { int x = 1; }
class Test {
	public static void main(String[] args) {

		T t = new T();
		System.out.println("t.x=" + t.x + when("t", t));

		S s = new S();
		System.out.println("s.x=" + s.x + when("s", s));

		s = t;
		System.out.println("s.x=" + s.x + when("s", s));

	}


	static String when(String name, Object t) {
		return " when " + name + " holds a "
			+ t.getClass() + " at run time.";
	}
}

t.x=1 when t holds a class T at run time.
s.x=0 when s holds a class S at run time.
s.x=0 when s holds a class T at run time.

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

class S { int x = 0; int z() { return x; } }
class T extends S { int x = 1; int z() { return x; } }
class Test {

	public static void main(String[] args) {
		T t = new T();
		System.out.println("t.z()=" + t.z() + when("t", t));
		S s = new S();
		System.out.println("s.z()=" + s.z() + when("s", s));
		s = t;
		System.out.println("s.z()=" + s.z() + when("s", s));
	}

	static String when(String name, Object t) {
		return " when " + name + " holds a "
			+ t.getClass() + " at run time.";
	}
}

t.z()=1 when t holds a class T at run time.
s.z()=0 when s holds a class S at run time.
s.z()=1 when s holds a class T at run time.

Следующий пример демонстрирует, что нулевая ссылка может использоваться, чтобы получить доступ к классу (static) переменная, не вызывая исключение:

class Test {
	static String mountain = "Chocorua";

	static Test favorite(){
		System.out.print("Mount ");
		return null;
	}

	public static void main(String[] args) {
		System.out.println(favorite().mountain);
	}
}

Mount Chocorua

15.10.2 Доступ к Задействованному использованию Суперкласса super

Предположите что выражение доступа к полю super.имя появляется в пределах класса C, и непосредственный суперкласс C является классом S. Затем super.имя обрабатывается точно, как будто это было выражение ((S)this).имя; таким образом это обращается к полю, названному именем текущего объекта, но с текущим объектом, просматриваемым как экземпляр суперкласса. Таким образом это может получить доступ к полю, названному именем, которое видимо в классе S, даже если то поле скрывается объявлением поля, названного именем в классе C.

Использование super демонстрируется следующим примером:

interface I { int x = 0; }
class T1 implements I { int x = 1; }
class T2 extends T1 { int x = 2; }
class T3 extends T2 {
	int x = 3;
	void test() {
		System.out.println("x=\t\t"+x);
		System.out.println("super.x=\t\t"+super.x);
		System.out.println("((T2)this).x=\t"+((T2)this).x);
		System.out.println("((T1)this).x=\t"+((T1)this).x);
		System.out.println("((I)this).x=\t"+((I)this).x);
	}
}
class Test {
	public static void main(String[] args) {
		new T3().test();
	}
}

x=					3
super.x=					2
((T2)this).x=					2
((T1)this).x=					1
((I)this).x=					0

((T2)this).x

15.11 Выражений Вызова метода

MethodInvocation:

	MethodName ( ArgumentListopt )

	Primary . Identifier ( ArgumentListopt )

	super . Identifier ( ArgumentListopt )

ArgumentList:

	Expression

	ArgumentList , Expression

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

15.11.1 Шаг 1 времени компиляции: Определите Класс или Интерфейс, чтобы Искать

• Если формой является MethodName, то есть три подслучая:
  • Если это - простое имя, то есть, только Идентификатор, то именем метода является Идентификатор и класс, или интерфейс, чтобы искать является тем, объявление которого содержит вызов метода.
  • Если это - полностью определенное имя формы TypeName . Идентификатор, тогда именем метода является Идентификатор, и класс поиска является тем, названным TypeName. Если TypeName является именем интерфейса, а не класса, то ошибка времени компиляции происходит, потому что эта форма может вызвать только static методы и интерфейсы имеют нет static методы.
  • Во всех других случаях у полностью определенного имени есть форма FieldName . Идентификатор; тогда именем метода является Идентификатор и класс, или интерфейс, чтобы искать является объявленным типом поля, названного FieldName.
• Если форма является Основной . Идентификатор, тогда именем метода является Идентификатор и класс, или интерфейс, который будет искаться, является типом Основного выражения.
• Если форма super . Идентификатор, тогда именем метода является Идентификатор, и класс, который будет искаться, является суперклассом класса, объявление которого содержит вызов метода. Ошибка времени компиляции происходит, если такой вызов метода происходит в интерфейсе, или в классе Object, или в a static метод, статический инициализатор, или инициализатор для a static переменная. Из этого следует, что вызов метода этой формы может появиться только в классе кроме Object, и только в теле метода экземпляра, теле конструктора, или инициализаторе для переменной экземпляра.

15.11.2 Шаг 2 времени компиляции: Определите Сигнатуру метода

15.11.2.1 Найдите Методы, которые Применимы и Доступны

• Число параметров в объявлении метода равняется числу выражений параметра в вызове метода.
• Тип каждого фактического параметра может быть преобразован преобразованием вызова метода (§5.3) к типу соответствующего параметра. Преобразование вызова метода является тем же самым как преобразованием присвоения (§5.2), за исключением того, что константы типа int неявно никогда не сужаются к byte, short, или char.

Доступно ли объявление метода для вызова метода, зависит от модификатора доступа (public, ни один, protected, или private) в объявлении метода и на том, где вызов метода появляется.

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

В примере программы:

public class Doubler {
	static int two() { return two(1); }
	private static int two(int i) { return 2*i; }
}

class Test extends Doubler {	
	public static long two(long j) {return j+j; }

	public static void main(String[] args) {
		System.out.println(two(3));
		System.out.println(Doubler.two(3)); // compile-time error
	}
}

Другой пример:

class ColoredPoint {
	int x, y;
	byte color;
	void setColor(byte color) { this.color = color; }
}

class Test {
	public static void main(String[] args) {
		ColoredPoint cp = new ColoredPoint();
		byte color = 37;
		cp.setColor(color);
		cp.setColor(37);											// compile-time error
	}
}

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

	void setColor(int color) { this.color = (byte)color; }

15.11.2.2 Выберите Самый определенный Метод

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

Точное определение следующие. Позвольте м. быть именем и предполагать, что есть два объявления методов, названных м., каждый имеющий n параметры. Предположите, что одно объявление появляется в пределах класса или интерфейса T и что типы параметров являются T1..., Tn; предположите кроме того, что другое объявление появляется в пределах класса или интерфейса U и что типы параметров являются U1..., Un. Затем метод м. объявленного в T является более определенным, чем метод м. объявил в U если и только если оба из следующего являются истиной:

• T может быть преобразован в U преобразованием вызова метода.
• Tj может быть преобразован в Uj преобразованием вызова метода, для всего j от 1 к n.

Если есть точно один максимально определенный метод, то это - фактически самый определенный метод; это является обязательно более определенным чем любой другой метод, который применим и доступен. Это тогда подвергается некоторым дальнейшим проверкам времени компиляции как описано в §15.11.3.

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

15.11.2.3 Пример: Перегрузка Неоднозначности

class Point { int x, y; }
class ColoredPoint extends Point { int color; }

class Test {

	static void test(ColoredPoint p, Point q) {
		System.out.println("(ColoredPoint, Point)");
	}

	static void test(Point p, ColoredPoint q) {
		System.out.println("(Point, ColoredPoint)");
	}

	public static void main(String[] args) {
		ColoredPoint cp = new ColoredPoint();
		test(cp, cp);											// compile-time error
	}
}

Если третье определение test были добавлены:

	static void test(ColoredPoint p, ColoredPoint q) {
		System.out.println("(ColoredPoint, ColoredPoint)");
	}

15.11.2.4 Пример: Возвратите Тип, Не Продуманный

class Point { int x, y; }
class ColoredPoint extends Point { int color; }
class Test {

	static int test(ColoredPoint p) {
		return color;
	}

	static String test(Point p) {
		return "Point";
	}

	public static void main(String[] args) {
		ColoredPoint cp = new ColoredPoint();
		String s = test(cp);											// compile-time error
	}
}

15.11.2.5 Пример: Разрешение времени компиляции

Так, например, рассмотрите две единицы компиляции, один для класса Point:

package points;
public class Point {
	public int x, y;
	public Point(int x, int y) { this.x = x; this.y = y; }
	public String toString() { return toString(""); }

	public String toString(String s) {
		return "(" + x + "," + y + s + ")";
	}
}

package points;
public class ColoredPoint extends Point {

	public static final int
		RED = 0, GREEN = 1, BLUE = 2;

	public static String[] COLORS =
		{ "red", "green", "blue" };
	public byte color;

	public ColoredPoint(int x, int y, int color) {
		super(x, y); this.color = (byte)color;
	}

	/** Copy all relevant fields of the argument into
		    this ColoredPoint object. */
	public void adopt(Point p) { x = p.x; y = p.y; }

	public String toString() {
		String s = "," + COLORS[color];
		return super.toString(s);
	}
}

import points.*;
class Test {
	public static void main(String[] args) {
		ColoredPoint cp =
			new ColoredPoint(6, 6, ColoredPoint.RED);
		ColoredPoint cp2 =
			new ColoredPoint(3, 3, ColoredPoint.GREEN);
		cp.adopt(cp2);
		System.out.println("cp: " + cp);
	}
}

cp: (3,3,red)

Заметьте, между прочим, что самый определенный метод (действительно, единственный применимый метод) для вызова метода adopt имеет подпись, которая указывает на метод одного параметра, и параметр имеет тип Point. Эта подпись становится частью двоичного представления класса Test произведенный компилятором и используется вызовом метода во время выполнения.

Предположите программиста, о котором сообщают эта ошибка программного обеспечения и специалист по обслуживанию points пакет решил, после должного обдумывания, исправить это, добавляя метод к классу ColoredPoint:

public void adopt(ColoredPoint p) {
	adopt((Point)p); color = p.color;
}

cp: (3,3,red)

cp: (3,3,green)

public void adopt(Point p) {
	if (p instanceof ColoredPoint)
		color = ((ColoredPoint)p).color;
	x = p.x; y = p.y;
}

public void adopt(Point p) {
	if (p instanceof ColoredPoint)
		color = ((ColoredPoint)p).color;
	super.adopt(p);
}

15.11.3 Шаг 3 времени компиляции: Выбранный Метод является Соответствующим?

• Если вызов метода имеет, перед левой круглой скобкой MethodName Идентификатора формы, и вызов метода появляются в пределах a static метод, статический инициализатор, или инициализатор для a static переменная, тогда объявление времени компиляции должно быть static. Если, вместо этого, объявление времени компиляции для вызова метода для метода экземпляра, то ошибка времени компиляции происходит. (Причина состоит в том, что вызов метода этой формы не может использоваться, чтобы вызвать метод экземпляра в местах где this (§15.7.2) не определяется.)
• Если вызов метода имеет, перед левой круглой скобкой, MethodName формы TypeName . Идентификатор, тогда объявление времени компиляции должно быть static. Если объявление времени компиляции для вызова метода для метода экземпляра, то ошибка времени компиляции происходит. (Причина состоит в том, что вызов метода этой формы не определяет ссылку на объект, который может служить this в пределах метода экземпляра.)
• Если объявление времени компиляции для вызова метода void, тогда вызов метода должен быть высокоуровневым выражением, то есть, Выражением в операторе выражения (§14.7) или в части ForInit или ForUpdate a for оператор (§14.12), или ошибка времени компиляции происходит. (Причина состоит в том, что такой вызов метода не производит значения и так должен использоваться только в ситуации, где значение не необходимо.)

• Имя метода.
• Класс или интерфейс, который содержит объявление времени компиляции.
• Число параметров и типы параметров, в порядке.
• Тип результата, или void, как объявлено в объявлении времени компиляции.
• Режим вызова, вычисленный следующим образом:
  • Если объявление времени компиляции имеет static модификатор, тогда режим вызова static.
  • Иначе, если объявление времени компиляции имеет private модификатор, тогда режим вызова nonvirtual.
  • Иначе, если часть вызова метода перед левой круглой скобкой имеет форму super . Идентификатор, тогда режим вызова super.
  • Иначе, если объявление времени компиляции находится в интерфейсе, то режим вызова interface.
  • Иначе, режим вызова virtual.

15.11.4 Оценка времени выполнения Вызова метода

15.11.4.1 Вычислите Целевую Ссылку (В случае необходимости)

• Если первое производство для MethodInvocation, который включает MethodName, включается, то есть три подслучая:
  • Если MethodName является простым именем, то есть, только Идентификатор, то есть два подслучая:
    • Если режим вызова static, тогда нет никакой целевой ссылки.
    • Иначе, целевая ссылка является значением this.
  • Если MethodName является полностью определенным именем формы TypeName . Идентификатор, тогда нет никакой целевой ссылки.
  • Если MethodName является полностью определенным именем формы FieldName . Идентификатор, тогда есть два подслучая:
    • Если режим вызова static, тогда нет никакой целевой ссылки.
    • Иначе, целевая ссылка является значением выражения FieldName.
• Если второе производство для MethodInvocation, который включает Основное устройство, включается, то есть два подслучая:
  • Если режим вызова static, тогда нет никакой целевой ссылки. Основное выражение оценивается, но результат тогда отбрасывается.
  • Иначе, Основное выражение оценивается, и результат используется в качестве целевой ссылки.

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

• Если третье производство для MethodInvocation, который включает ключевое слово super, включается, тогда целевая ссылка является значением this.

15.11.4.2 Оцените Параметры

15.11.4.3 Проверьте Доступность Типа и Метода

Виртуальная машина Java должна обеспечить как часть редактирования, что метод м. все еще существует в типе T. Если это не истина, то a NoSuchMethodError (который является подклассом IncompatibleClassChangeError) происходит. Если режим вызова interface, тогда виртуальная машина должна также проверить, что целевой ссылочный тип все еще реализует указанный интерфейс. Если целевой ссылочный тип все еще не реализует интерфейс, то IncompatibleClassChangeError происходит.

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

• Если T находится в том же самом пакете как C, то T доступен.
• Если T находится в различном пакете чем C, и T public, тогда T доступен.

• Если м. public, тогда м. доступен. (Все элементы интерфейсов public (§9.2)).
• Если м. protected, тогда м. доступен, если и только если или T находится в том же самом пакете как C, или C является T или подклассом T.
• Если у м. есть значение по умолчанию (пакет) доступ, то м. доступен, если и только если T находится в том же самом пакете как C.
• Если м. private, тогда м. доступен, если и только если и C T.

15.11.4.4 Определите местоположение Метода, чтобы Вызвать

Если режим вызова static, никакая целевая ссылка не необходима, и переопределение не позволяется. Метод м. класса T является тем, который будет вызван.

Иначе, метод экземпляра должен быть вызван и есть целевая ссылка. Если целевая ссылка null, a NullPointerException бросается в эту точку. Иначе, целевая ссылка, как говорят, обращается к целевому объекту и будет использоваться в качестве значения ключевого слова this в вызванном методе. Другие четыре возможности для режима вызова тогда рассматривают.

Если режим вызова nonvirtual, переопределение не позволяется. Метод м. класса T является тем, который будет вызван.

Иначе, режим вызова interface, virtual, или super, и переопределение может произойти. Используется динамический поиск метода. Динамический процесс поиска запускается с класса S, определенного следующим образом:

• Если режим вызова interface или virtual, тогда S является первоначально фактическим классом R времени выполнения целевого объекта. Если целевой объект является массивом, R является классом Object. (Отметьте это режимом вызова interface, R обязательно реализует T; для режима вызова virtual, R является обязательно или T или подклассом T.),
• Если режим вызова super, тогда S является первоначально суперклассом класса C, который содержит вызов метода.

1. Если класс S содержит объявление для метода, названного м. с тем же самым дескриптором (то же самое число параметров, те же самые типы параметра, и тот же самый тип возврата) требуемый вызовом метода как определено во время компиляции (§15.11.3), то это - метод, который будет вызван, и процедура завершается. (Мы отмечаем, что как часть загрузки и соединения процесса, что виртуальная машина проверяет, что метод переопределения, по крайней мере, столь же доступен как переопределенный метод; IncompatibleClassChangeError происходит если дело обстоит не так.)
2. Иначе, если S не является T, эта та же самая процедура поиска выполняется, используя суперкласс S; независимо от того, что это придумывает, результат этого поиска.

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

15.11.4.5 Создайте Фрейм, Синхронизируйтесь, Управление Передачей

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

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

Если метод м. является a native метод, но необходимый собственный, зависящий от реализации двоичный код не был загружен (§20.16.14, §20.16.13) или иначе не может быть динамически соединен, затем UnsatisfiedLinkError бросается.

Если метод м. не synchronized, управление передается телу метода м., который будет вызван.

Если метод м. synchronized, тогда объект должен быть заблокирован перед передачей управления. Никакие дальнейшие успехи не могут быть сделаны, пока текущий поток не может получить блокировку. Если есть целевая ссылка, то цель должна быть заблокирована; иначе Class объект для класса S, класса метода м., должен быть заблокирован. Управление тогда передается телу метода м., который будет вызван. Объект автоматически разблокирован, когда выполнение тела метода завершилось, или обычно или резко. Блокировка и разблокирование поведения состоят точно в том, как будто тело метода было встроено в a synchronized оператор (§14.17).

15.11.4.6 Примечание реализации: Объединение Фреймов

• У Класса C и класса S есть тот же самый загрузчик класса (§20.14), и класс S не SecurityManager или подкласс SecurityManager.
• У класса S нет никакого загрузчика класса (этот факт указывает, что это - системный класс); класс S не SecurityManager или подкласс SecurityManager; и метод м., как известно, не вызывает, прямо или косвенно, любой метод SecurityManager (§20.17) или любой из его подклассов.

15.11.4.7 Пример: Целевые Ссылочные и Статические Методы

class Test {
	static void mountain() {

		System.out.println("Monadnock");

	}

	static Test favorite(){
		System.out.print("Mount ");
		return null;
	}

	public static void main(String[] args) {
		favorite().mountain();
	}
}

Mount Monadnock

15.11.4.8 Пример: Порядок Оценки

Так, например, в:

class Test {
	public static void main(String[] args) {
		String s = "one";
		if (s.startsWith(s = "two"))
			System.out.println("oops");
	}
}

15.11.4.9 Пример: Переопределение

class Point {

	final int EDGE = 20;
	int x, y;

	void move(int dx, int dy) {
		x += dx; y += dy;
		if (Math.abs(x) >= EDGE || Math.abs(y) >= EDGE)
			clear();
	}

	void clear() {
		System.out.println("\tPoint clear");
		x = 0; y = 0;
	}
}

class ColoredPoint extends Point {
	int color;

	void clear() {
		System.out.println("\tColoredPoint clear");
		super.clear();
		color = 0;
	}
}

Этот метод тогда вызывается всякий раз, когда целевой объект для вызова clear a ColoredPoint. Даже метод move в Point вызывает clear метод класса ColoredPoint когда класс this ColoredPoint, как показано выводом этой тестовой программы:

class Test {
	public static void main(String[] args) {
		Point p = new Point();
		System.out.println("p.move(20,20):");
		p.move(20, 20);
		ColoredPoint cp = new ColoredPoint();
		System.out.println("cp.move(20,20):");
		cp.move(20, 20);
		p = new ColoredPoint();
		System.out.println("p.move(20,20), p colored:");
		p.move(20, 20);
	}
}

p.move(20,20):
	Point clear
cp.move(20,20):
	ColoredPoint clear
	Point clear
p.move(20,20), p colored:
	ColoredPoint clear
	Point clear

15.11.4.10 Пример: Вызов метода, использующий супер

Получая доступ к переменной экземпляра, super означает то же самое как бросок this (§15.10.2), но эта эквивалентность не сохраняется для вызова метода. Это демонстрируется примером:

class T1 {
	String s() { return "1"; }
}

class T2 extends T1 {
	String s() { return "2"; }
}

class T3 extends T2 {
	String s() { return "3"; }

	void test() {
		System.out.println("s()=\t\t"+s());
		System.out.println("super.s()=\t"+super.s());
		System.out.print("((T2)this).s()=\t");
			System.out.println(((T2)this).s());
		System.out.print("((T1)this).s()=\t");
			System.out.println(((T1)this).s());
	}
}

class Test {
	public static void main(String[] args) {
		T3 t3 = new T3();
		t3.test();
	}
}

s()=					3
super.s()=					2
((T2)this).s()=					3
((T1)this).s()=					3

15.12 Выражений Доступа Массива

ArrayAccess:

	ExpressionName [ Expression ]

	PrimaryNoNewArray [ Expression ]

Тип ссылочного выражения массива должен быть типом массива (вызовите это T[], заканчивается массив, компоненты которого имеют тип T) или ошибка времени компиляции. Затем тип выражения доступа массива является T.

Индексное выражение подвергается унарному числовому продвижению (§5.6.1); продвинутый тип должен быть int.

Результатом ссылки массива является переменная типа T, а именно, переменная в пределах массива, выбранного значением индексного выражения. Эту получающуюся переменную, которая является компонентом массива, никогда не рассматривают final, даже если ссылка массива была получена из a final переменная.

15.12.1 Оценка времени выполнения Доступа Массива

• Во-первых, ссылочное выражение массива оценивается. Если эта оценка завершается резко, то доступ массива завершается резко по той же самой причине, и индексное выражение не оценивается.
• Иначе, индексное выражение оценивается. Если эта оценка завершается резко, то доступ массива завершается резко по той же самой причине.
• Иначе, если значение ссылочного выражения массива null, тогда a NullPointerException бросается.
• Иначе, значение ссылочного выражения массива действительно обращается к массиву. Если значение индексного выражения является меньше чем нуль, или больше чем или равный длине массива, то IndexOutOfBoundsException бросается.
• Иначе, результатом ссылки массива является переменная типа T, в пределах массива, выбранного значением индексного выражения. (Отметьте, что эту получающуюся переменную, которая является компонентом массива, никогда не рассматривают final, даже если ссылочное выражение массива является a final переменная.)

15.12.2 Примеры: Порядок Оценки Доступа Массива

Таким образом, пример:

class Test {
	public static void main(String[] args) {
		int[] a = { 11, 12, 13, 14 };
		int[] b = { 0, 1, 2, 3 };
		System.out.println(a[(a=b)[3]]);
	}
}

14

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

class Test {
	public static void main(String[] args) {
		int index = 1;
		try {
			skedaddle()[index=2]++;
		} catch (Exception e) {
			System.out.println(e + ", index=" + index);
		}
	}
	static int[] skedaddle() throws Exception {
		throw new Exception("Ciao");
	}
}

java.lang.Exception: Ciao, index=1

Если ссылочное выражение массива производит null вместо ссылки на массив, тогда a NullPointerException бросается во время выполнения, но только после того, как все части ссылочного выражения массива были оценены и только если эти оценки, завершаемые обычно. Таким образом, пример:

class Test {

	public static void main(String[] args) {
		int index = 1;
		try {
			nada()[index=2]++;
		} catch (Exception e) {
			System.out.println(e + ", index=" + index);
		}
	}
	static int[] nada() { return null; }
}

java.lang.NullPointerException, index=2

class Test {

	public static void main(String[] args) {
		int[] a = null;
		try {
			int i = a[vamoose()];
			System.out.println(i);
		} catch (Exception e) {
			System.out.println(e);
		}
	}

	static int vamoose() throws Exception {
		throw new Exception("Twenty-three skidoo!");
	}
}

java.lang.Exception: Twenty-three skidoo!

15.13 Постфиксных Выражений

PostfixExpression:

	Primary

	ExpressionName

	PostIncrementExpression

	PostDecrementExpression

15.13.1 Имена

• Если это - простое имя, то есть, только Идентификатор, то есть два случая:
  • Если Идентификатор происходит в рамках параметра или локальной переменной, названной тем же самым Идентификатором, то тип ExpressionName является объявленным типом параметра или локальной переменной; кроме того значение ExpressionName является переменной, а именно, параметром или локальной переменной непосредственно.
  • Иначе, ExpressionName обрабатывается точно, как будто это было выражение доступа к полю (§15.10):
  this.Идентификатор
  • содержа ключевое слово this (§15.7.2).
• Иначе, если это - полностью определенное имя формы PackageName . Идентификатор, затем ошибка времени компиляции происходит.
• Иначе, если это - полностью определенное имя формы TypeName . Идентификатор, тогда это, обращается к a static поле класса или интерфейса называет TypeName. Ошибка времени компиляции происходит, если TypeName не называет класс или интерфейс. Ошибка времени компиляции происходит, если класс или интерфейс, названный TypeName, не содержат доступное статическое поле, названное Идентификатором. Тип ExpressionName является объявленным типом static поле. Значение ExpressionName является переменной, а именно, static поле непосредственно.
• Иначе, это - полностью определенное имя формы Ename . Идентификатор, где Ename является самостоятельно ExpressionName, и ExpressionName, обрабатывается точно, как будто это было выражение доступа к полю (§15.10): (Ename).Identifier

содержа заключенное в скобки выражение (§15.7.3).

15.13.2 Постфиксный Инкрементный Оператор ++

PostIncrementExpression:

	PostfixExpression ++

Во время выполнения, если оценка выражения операнда завершается резко, то постфиксное инкрементное выражение завершается резко по той же самой причине и никакому приращению, происходит. Иначе, значение 1 добавляется к значению переменной, и сумма сохранена назад в переменную. Перед дополнением двоичное числовое продвижение (§5.6.2) выполняется на значении 1 и значение переменной. В случае необходимости сумма сужается сужающимся примитивным преобразованием (§5.1.3) к типу переменной прежде, чем это будет сохранено. Значение постфиксного инкрементного выражения является значением переменной прежде, чем новое значение будет сохранено.

Переменная, которая объявляется final не может быть постепенно увеличен, потому что когда доступ a final переменная используется в качестве выражения, результатом является значение, не переменная. Таким образом это не может использоваться в качестве операнда постфиксного инкрементного оператора.

15.13.3 Постфиксный Декрементный Оператор --

PostDecrementExpression:

	PostfixExpression --

Во время выполнения, если оценка выражения операнда завершается резко, то постфиксное декрементное выражение завершается резко по той же самой причине и никакому decrementation, происходит. Иначе, значение 1 вычитается из значения переменной, и различие сохранено назад в переменную. Перед вычитанием двоичное числовое продвижение (§5.6.2) выполняется на значении 1 и значение переменной. В случае необходимости различие сужается сужающимся примитивным преобразованием (§5.1.3) к типу переменной прежде, чем это будет сохранено. Значение постфиксного декрементного выражения является значением переменной прежде, чем новое значение будет сохранено.

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

15.14 Унарных операторов

UnaryExpression:

	PreIncrementExpression

	PreDecrementExpression

	+ UnaryExpression

	- UnaryExpression

	UnaryExpressionNotPlusMinus

PreIncrementExpression:

	++ UnaryExpression

PreDecrementExpression:

	-- UnaryExpression

UnaryExpressionNotPlusMinus:

	PostfixExpression

	~ UnaryExpression

	! UnaryExpression

	CastExpression

CastExpression:

	( PrimitiveType ) UnaryExpression

	( ReferenceType ) UnaryExpressionNotPlusMinus

Первая потенциальная неоднозначность возникла бы в выражениях такой как (p)+q, который смотрит к C или программисту на C++, как если бы это могло быть любой быть броском, чтобы ввести p из унарного + работа на q, или сложение в двоичной системе двух количеств p и q. В C и C++, синтаксический анализатор решает эту проблему, выполняя ограниченное количество семантического анализа, поскольку это анализирует, так, чтобы это знало ли p имя типа или имя переменной.

Java берет другой подход. Результат + оператор должен быть числовым, и все имена типов, включенные в, набирает числовые значения, известные ключевые слова. Таким образом, если p ключевое слово, называя тип примитива, тогда (p)+q может иметь смысл только как бросок унарного выражения. Однако, если p не ключевое слово, называя тип примитива, тогда (p)+q может иметь смысл только как работу двоичной арифметики. Подобные комментарии применяются к - оператор. Грамматика, показанная выше разделений CastExpression в два случая, чтобы сделать это различие. Нетерминальный UnaryExpression включает весь унарный оператор, но нетерминальный UnaryExpressionNotPlusMinus исключает использование всех унарных операторов, которые могли также быть бинарными операторами, которые в Java являются + и -.

Вторая потенциальная неоднозначность то, что выражение (p)++ к C или программисту на C++, могло казаться, был или постфиксным инкрементом заключенного в скобки выражения или начало броска, например, в (p)++q. Как прежде, синтаксические анализаторы для C и C++ знают ли p имя типа или имя переменной. Но синтаксический анализатор, используя только предвидение с одним маркером и никакой семантический анализ во время синтаксического анализа не был бы в состоянии сказать, когда ++ предварительный маркер, ли (p) должен считаться Основным выражением или оставлен в покое для более позднего рассмотрения как часть CastExpression.

В Java, результате ++ оператор должен быть числовым, и все имена типов, включенные в, набирает числовые значения, известные ключевые слова. Таким образом, если p ключевое слово, называя тип примитива, тогда (p)++ может иметь смысл только как бросок префиксного инкрементного выражения, и должен быть операнд такой как q после ++. Однако, если p не ключевое слово, называя тип примитива, тогда (p)++ может иметь смысл только как постфиксный инкремент p. Подобные комментарии применяются к -- оператор. Нетерминальный UnaryExpressionNotPlusMinus поэтому также исключает использование префиксных операторов ++ и --.

15.14.1 Префиксный Инкрементный Оператор ++

Во время выполнения, если оценка выражения операнда завершается резко, то префиксное инкрементное выражение завершается резко по той же самой причине и никакому приращению, происходит. Иначе, значение 1 добавляется к значению переменной, и сумма сохранена назад в переменную. Перед дополнением двоичное числовое продвижение (§5.6.2) выполняется на значении 1 и значение переменной. В случае необходимости сумма сужается сужающимся примитивным преобразованием (§5.1.3) к типу переменной прежде, чем это будет сохранено. Значение префиксного инкрементного выражения является значением переменной после того, как новое значение сохранено.

Переменная, которая объявляется final не может быть постепенно увеличен, потому что когда доступ a final переменная используется в качестве выражения, результатом является значение, не переменная. Таким образом это не может использоваться в качестве операнда префиксного инкрементного оператора.

15.14.2 Префиксный Декрементный Оператор --

Во время выполнения, если оценка выражения операнда завершается резко, то префиксное декрементное выражение завершается резко по той же самой причине и никакому decrementation, происходит. Иначе, значение 1 вычитается из значения переменной, и различие сохранено назад в переменную. Перед вычитанием двоичное числовое продвижение (§5.6.2) выполняется на значении 1 и значение переменной. В случае необходимости различие сужается сужающимся примитивным преобразованием (§5.1.3) к типу переменной прежде, чем это будет сохранено. Значение префиксного декрементного выражения является значением переменной после того, как новое значение сохранено.

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

15.14.3 Унарный Плюс Оператор +

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

15.14.4 Оператор унарный минус -

Во время выполнения значение унарного плюс выражение является арифметическим отрицанием продвинутого значения операнда.

Для целочисленных значений отрицание является тем же самым как вычитанием от нуля. Использование Java two's-дополнительное представление для целых чисел, и диапазон two's-дополнительных значений не симметрично, таким образом, отрицание максимального отрицания int или long результаты в том же самом максимальном отрицательном числе. Переполнение происходит в этом случае, но никакое исключение не выдается. Для всех целочисленных значений x, -x равняется (~x)+1.

Для значений с плавающей точкой отрицание не является тем же самым как вычитанием от нуля, потому что если x +0.0, тогда 0.0-x равняется +0.0, но -x равняется -0.0. Унарный минус просто инвертирует знак числа с плавающей точкой. Особые случаи интереса:

• Если операндом является НЭН, результатом является НЭН (вспомните, что у НЭН нет никакого знака).
• Если операнд является бесконечностью, результатом является бесконечность противоположного знака.
• Если операнд является нулем, результатом является нуль противоположного знака.

15.14.5 Поразрядный Дополнительный Оператор ~

Во время выполнения значение унарного поразрядного дополнительного выражения является поразрядным дополнением продвинутого значения операнда; отметьте что во всех случаях, ~x равняется (-x)-1.

15.14.6 Логический Дополнительный Оператор !

Во время выполнения значение унарного логического дополнительного выражения true если значение операнда false и false если значение операнда true.

15.15 Выражений Броска

CastExpression:

	( PrimitiveType Dimsopt ) UnaryExpression

	( ReferenceType ) UnaryExpressionNotPlusMinus

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

Во время выполнения значение операнда преобразовывается, бросая преобразование (§5.4) к типу, определенному оператором броска.

Не все броски разрешаются языком Java. Некоторые броски приводят к ошибке во время компиляции. Например, примитивное значение не может быть брошено к ссылочному типу. Некоторые броски, как могут доказывать, во время компиляции, всегда корректны во время выполнения. Например, это всегда корректно, чтобы преобразовать значение типа класса к типу его суперкласса; во время выполнения такой бросок не должен потребовать никакого специального действия. Наконец, некоторые броски, как могут доказывать, не являются или всегда корректными или всегда неправильными во время компиляции. Во время выполнения такие броски требуют теста. A ClassCastException бросается, если бросок, как находят, во время выполнения непозволителен.

15.16 Мультипликативных Операторов

MultiplicativeExpression:

	UnaryExpression

	MultiplicativeExpression * UnaryExpression

	MultiplicativeExpression / UnaryExpression

	MultiplicativeExpression % UnaryExpression

15.16.1 Оператор умножения *

Если целочисленное умножение переполняется, то результатом являются биты младшего разряда математического продукта как представлено в некотором достаточно большом two's-дополнительном формате. В результате, если переполнение происходит, то знак результата, возможно, не то же самое как знак математического продукта двух значений операнда.

Результатом умножения с плавающей точкой управляют правила арифметики IEEE 754:

• Если любым операндом является НЭН, результатом является НЭН.
• Если результатом не является НЭН, знак результата положителен, если у обоих операндов есть тот же самый знак, и отрицательный, если у операндов есть различные знаки.
• Умножение бесконечности нулем приводит к НЭН.
• Умножение бесконечности конечным значением приводит к бесконечности со знаком. Знак определяется вышеизложенным правилом.
• В остающихся случаях, где ни один бесконечность или НЭН не включается, вычисляется продукт. Если величина продукта является слишком большой, чтобы представить, мы говорим переполнения работы. Результатом является тогда бесконечность соответствующего знака. Если величина является слишком маленькой, чтобы представить, мы говорим потери значимости работы; результатом является тогда нуль соответствующего знака. Иначе, продукт округляется к самому близкому представимому значению, используя режим раунда-к-самому-близкому IEEE 754. Язык Java требует поддержки постепенной потери значимости как определено IEEE 754 (§4.2.4).

15.16.2 Оператор подразделения /

Целочисленное деление округляется к 0. Таким образом, частное, произведенное для операндов n и d, которые являются целыми числами после двоичного числового продвижения (§5.6.2), является целочисленным значением q, чья величина как можно больше, удовлетворяя; кроме того q положителен, когда и n и d имеют тот же самый знак, но q отрицателен, когда и n и d имеют противоположные знаки. Есть один особый случай, который не удовлетворяет это правило: если дивиденд является отрицательным целым числом самой большой величины для ее типа, и делитель -1, тогда целочисленное переполнение происходит, и результат равен дивиденду. Несмотря на переполнение, никакое исключение не выдается в этом случае. С другой стороны, если значение делителя в целочисленном делении 0, тогда ArithmeticException бросается.

Результат подразделения с плавающей точкой определяется спецификацией арифметики IEEE:

• Если любым операндом является НЭН, результатом является НЭН.
• Если результатом не является НЭН, знак результата положителен, если у обоих операндов есть тот же самый знак, отрицательный, если у операндов есть различные знаки.
• Подразделение бесконечности бесконечностью приводит к НЭН.
• Подразделение бесконечности конечным значением приводит к бесконечности со знаком. Знак определяется вышеизложенным правилом.
• Подразделение конечного значения бесконечностью приводит к нулю со знаком. Знак определяется вышеизложенным правилом.
• Подразделение нуля нулем приводит к НЭН; подразделение нуля любым другим конечным значением приводит к нулю со знаком. Знак определяется вышеизложенным правилом.
• Подразделение ненулевого конечного значения нулем приводит к бесконечности со знаком. Знак определяется вышеизложенным правилом.
• В остающихся случаях, где ни бесконечность, ни нуль, ни НЭН не включаются, вычисляется частное. Если величина частного является слишком большой, чтобы представить, мы говорим переполнения работы; результатом является тогда бесконечность соответствующего знака. Если величина является слишком маленькой, чтобы представить, мы говорим, что потери значимости работы и результат являются тогда нулем соответствующего знака. Иначе, частное округляется к самому близкому представимому значению, используя режим раунда-к-самому-близкому IEEE 754. Язык Java требует поддержки постепенной потери значимости как определено IEEE 754 (§4.2.4).

15.16.3 Оператор остатка %

В C и C++, оператор остатка принимает только интегральные операнды, но в Java, это также принимает операнды с плавающей точкой.

Работа остатка для операндов, которые являются целыми числами после двоичного числового продвижения (§5.6.2), производит значение результата так, что (a/b)*b+(a%b) равно a. Эти идентификационные данные содержат даже в особом случае, что дивиденд является отрицательным целым числом самой большой величины для ее типа, и делитель -1 (остаток 0). Это следует из этого правила, что результат работы остатка может быть отрицательным, только если дивиденд отрицателен, и может быть положительным, только если дивиденд положителен; кроме того величина результата всегда является меньше чем величина делителя. Если значение делителя для целочисленного оператора остатка 0, тогда ArithmeticException бросается.

Примеры:

5%3 produces 2							(note that 5/3 produces 1)
5%(-3) produces 2							(note that 5/(-3) produces -1)
(-5)%3 produces -2							(note that (-5)/3 produces -1)
(-5)%(-3) produces -2							(note that (-5)/(-3) produces 1)

Результат Java работа остатка с плавающей точкой определяется правилами арифметики IEEE:

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

Примеры:

5.0%3.0 produces 2.0
5.0%(-3.0) produces 2.0
(-5.0)%3.0 produces -2.0
(-5.0)%(-3.0) produces -2.0

15.17 Аддитивных Операторов

AdditiveExpression:

	MultiplicativeExpression

	AdditiveExpression + MultiplicativeExpression

	AdditiveExpression - MultiplicativeExpression

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

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

15.17.1 Оператор Конкатенации строк +

15.17.1.1 Преобразование строк

Значение x типа примитива T сначала преобразовывается в ссылочное значение как будто, давая это как параметр соответствующему выражению создания экземпляра класса:

• Если T boolean, тогда используйте new Boolean(x) (§20.4).
• Если T char, тогда используйте new Character(x) (§20.5).
• Если T byte, short, или int, тогда используйте new Integer(x) (§20.7).
• Если T long, тогда используйте new Long(x) (§20.8).
• Если T float, тогда используйте new Float(x) (§20.9).
• Если T double, тогда используйте new Double(x) (§20.10).

Теперь только ссылочные значения нужно рассмотреть. Если ссылка null, это преобразовывается в строку"null"(четыре символа ASCII n, u, l, l). Иначе, преобразование выполняется как будто вызовом toString метод объекта, на который ссылаются, без параметров; но если результат вызова toString метод null, тогда строка"null"используется вместо этого. toString метод (§20.1.2) определяется исконным классом Object (§20.1); много классов переопределяют это, особенно Boolean, Character, Integer, Long, Float, Double, и String.

15.17.1.2 Оптимизация Конкатенации строк

Для примитивных объектов реализация может также оптимизировать далеко создание объекта обертки, преобразовывая непосредственно от типа примитива до строки.

15.17.1.3 Примеры Конкатенации строк

"The square root of 2 is " + Math.sqrt(2)

"The square root of 2 is 1.4142135623730952"

a + b + c

(a + b) + c

1 + 2 + " fiddlers"

"3 fiddlers"

"fiddlers " + 1 + 2

"fiddlers 12"

class Bottles {

	static void printSong(Object stuff, int n) {
		String plural = "s";
		loop: while (true) {
			System.out.println(n + " bottle" + plural
				+ " of " + stuff + " on the wall,");
			System.out.println(n + " bottle" + plural
				+ " of " + stuff + ";");
			System.out.println("You take one down "
				+ "and pass it around:");
			--n;
			plural = (n == 1) ? "" : "s";
			if (n == 0)
				break loop;
			System.out.println(n + " bottle" + plural
				+ " of " + stuff + " on the wall!");
			System.out.println();
		}
		System.out.println("No bottles of " +
								stuff + " on the wall!");
	}

}

3 bottles of slime on the wall,
3 bottles of slime;
You take one down and pass it around:
2 bottles of slime on the wall!

2 bottles of slime on the wall,
2 bottles of slime;
You take one down and pass it around:
1 bottle of slime on the wall!

1 bottle of slime on the wall,
1 bottle of slime;
You take one down and pass it around:
No bottles of slime on the wall!

"You take one down and pass it around:"

15.17.2 Аддитивные Операторы (+ и -) для Числовых Типов

Двоичное числовое продвижение выполняется на операндах (§5.6.2). Тип аддитивного выражения на числовых операндах является продвинутым типом своих операндов. Если этот продвинутый тип int или long, тогда целочисленная арифметика выполняется; если этот продвинутый тип float или double, тогда арифметика с плавающей точкой выполняется.

Дополнение является коммутативной работой, если у выражений операнда нет никаких побочных эффектов. Целочисленное дополнение ассоциативно, когда операнды являются всем тем же самым типом, но дополнение с плавающей точкой не ассоциативно.

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

Результат дополнения с плавающей точкой определяется, используя следующие правила арифметики IEEE:

• Если любым операндом является НЭН, результатом является НЭН.
• Суммой двух бесконечностей противоположного знака является НЭН.
• Сумма двух бесконечностей того же самого знака является бесконечностью того знака.
• Сумма бесконечности и конечного значения равна бесконечному операнду.
• Сумма двух нулей противоположного знака является положительным нулем.
• Сумма двух нулей того же самого знака является нулем того знака.
• Сумма нуля и ненулевого конечного значения равна ненулевому операнду.
• Сумма двух ненулевых конечных значений той же самой величины и противоположного знака является положительным нулем.
• В остающихся случаях, где ни бесконечность, ни нуль, ни НЭН не включаются, и операнды, имеют тот же самый знак или имеют различные величины, сумма вычисляется. Если величина суммы является слишком большой, чтобы представить, мы говорим переполнения работы; результатом является тогда бесконечность соответствующего знака. Если величина является слишком маленькой, чтобы представить, мы говорим потери значимости работы; результатом является тогда нуль соответствующего знака. Иначе, сумма округляется к самому близкому представимому значению, используя режим раунда-к-самому-близкому IEEE 754. Язык Java требует поддержки постепенной потери значимости как определено IEEE 754 (§4.2.4).

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

15.18 Операторов Сдвига

ShiftExpression:

	AdditiveExpression

	ShiftExpression << AdditiveExpression

	ShiftExpression >> AdditiveExpression

	ShiftExpression >>> AdditiveExpression

Если продвинутый тип левого операнда int, только пять битов самых низкоуровневых правого операнда используются в качестве расстояния сдвига. Это - как будто правый операнд был подвергнут поразрядной логической операции И & (§15.21.1) со значением маски 0x1f. Расстояние сдвига, фактически используемое, находится поэтому всегда в диапазоне от 0 до 31, включительно.

Если продвинутый тип левого операнда long, тогда только шесть битов самых низкоуровневых правого операнда используются в качестве расстояния сдвига. Это - как будто правый операнд был подвергнут поразрядной логической операции И & (§15.21.1) со значением маски 0x3f. Расстояние сдвига, фактически используемое, находится поэтому всегда в диапазоне от 0 до 63, включительно.

Во время выполнения операции сдвига выполняются на дополнительном целочисленном представлении two значения левого операнда.

Значение n<<s n лево-смещенный s позиции двоичного разряда; это эквивалентно (даже если переполнение происходит) к умножению два к питанию s.

Значение n>>s n смещенный на право s позиции двоичного разряда с расширением знака. Получающееся значение. Для неотрицательных значений n, это эквивалентно усечению целочисленного деления, как вычислено оператором целочисленного деления /, два к питанию s.

Значение n>>>s n смещенный на право s позиции двоичного разряда с дополнением нулями. Если n положительно, тогда результатом является то же самое как тот из n>>s; если n отрицательно, результат равен тому из выражения (n>>s)+(2<<~s) если тип левого операнда int, и к результату выражения (n>>s)+(2L<<~s) если тип левого операнда long. Добавленный термин (2<<~s) или (2L<<~s) уравновешивает распространенный знаковый бит. (Отметьте что из-за неявного маскирования правого операнда оператора сдвига, ~s поскольку расстояние сдвига эквивалентно 31-s смещаясь int значение и к 63-s смещаясь a long значение.)

15.19 Операторов отношения

RelationalExpression:

	ShiftExpression

	RelationalExpression < ShiftExpression

	RelationalExpression > ShiftExpression

	RelationalExpression <= ShiftExpression

	RelationalExpression >= ShiftExpression

	RelationalExpression instanceof ReferenceType

15.19.1 Числовые Операторы сравнения <, <=, >, и >=

Результат сравнения с плавающей точкой, как определено спецификацией стандарта IEEE 754:

• Если любым операндом является НЭН, то результат false.
• Все значения кроме НЭН упорядочиваются с отрицательной бесконечностью меньше чем все конечные значения, и положительная бесконечность, больше чем все конечные значения.
• Положительный нулевой и отрицательный нуль считают равным. Поэтому, -0.0<0.0 false, например, но -0.0<=0.0 true. (Отметьте, однако, что методы Math.min (§20.11.27, §20.11.28) и Math.max (§20.11.31, §20.11.32), обрабатывают отрицательный нуль, как являющийся строго меньшим чем положительный нуль.)

• Значение, произведенное < оператор true если значение левого операнда является меньше чем значение правого операнда, и иначе false.
• Значение, произведенное <= оператор true если значение левого операнда меньше чем или равно значению правого операнда, и иначе false.
• Значение, произведенное > оператор true если значение левого операнда больше чем значение правого операнда, и иначе false.
• Значение, произведенное >= оператор true если значение левого операнда больше чем или равно значению правого операнда, и иначе false.

15.19.2 Оператор Сравнения типов instanceof

Во время выполнения, результат instanceof оператор true если значение RelationalExpression не null и ссылка могла быть брошена (§15.15) к ReferenceType, не повышая a ClassCastException. Иначе результат false.

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

Рассмотрите пример программы:

class Point { int x, y; }
class Element { int atomicNumber; }
class Test {
	public static void main(String[] args) {
		Point p = new Point();
		Element e = new Element();
		if (e instanceof Point) {											// compile-time error
			System.out.println("I get your point!");
			p = (Point)e;										// compile-time error
		}
	}
}

class Point extends Element { int x, y; }

15.20 Операторов Равенства

EqualityExpression:

	RelationalExpression

	EqualityExpression == RelationalExpression

	EqualityExpression != RelationalExpression

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

Во всех случаях, a!=b приводит к тому же самому результату как !(a==b). Операторы равенства являются коммутативными, если у выражений операнда нет никаких побочных эффектов.

15.20.1 Числовые Операторы Равенства == и !=

Тестирование равенства с плавающей точкой выполняется в соответствии с правилами стандарта IEEE 754:

• Если любым операндом является НЭН, то результат == false но результат != true. Действительно, тест x!=x истина если и только если значение x НЭН. (Методы Float.isNaN (§20.9.19) и Double.isNaN (§20.10.17) может также использоваться, чтобы протестировать, является ли значением НЭН.)
• Положительный нулевой и отрицательный нуль считают равным. Поэтому, -0.0==0.0 true, например.
• Иначе, два отличных значения с плавающей точкой считают неравными операторы равенства. В частности есть одно значение, представляющее положительную бесконечность и одно значение, представляющее отрицательную бесконечность; каждый сравнивается равный только себе, и каждый сравнивается неравный всем другим значениям.

• Значение, произведенное == оператор true если значение левого операнда равно значению правого операнда; иначе, результат false.
• Значение, произведенное != оператор true если значение левого операнда не равно значению правого операнда; иначе, результат false.

15.20.2 Булевы Операторы Равенства == и !=

Результат == true если операнды - оба true или оба false; иначе, результат false.

Результат != false если операнды - оба true или оба false; иначе, результат true. Таким образом != ведет себя то же самое как ^ (§15.21.2), когда применялся к булевым операндам.

15.20.3 Ссылочные Операторы Равенства == и !=

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

Во время выполнения, результат == true если значения операнда - оба null или оба обращаются к тому же самому объекту или массиву; иначе, результат false.

Результат != false если значения операнда - оба null или оба обращаются к тому же самому объекту или массиву; иначе, результат true.

В то время как == может использоваться, чтобы сравнить ссылки типа String, такой тест равенства определяет, обращаются ли эти два операнда к тому же самому String объект. Результат false если операнды отличны String объекты, даже если они содержат ту же самую последовательность символов. Содержание двух строк s и t может быть протестирован на равенство вызовом метода s.equals(t) (§20.12.9). См. также §3.10.5 и §20.12.47.

15.21 Логических операторов и Логические операторы

AndExpression:

	EqualityExpression

	AndExpression & EqualityExpression

ExclusiveOrExpression:

	AndExpression

	ExclusiveOrExpression ^ AndExpression

InclusiveOrExpression:

	ExclusiveOrExpression

	InclusiveOrExpression | ExclusiveOrExpression

15.21.1 Целочисленные Логические операторы &, ^, и |

Для &, значение результата является поразрядным И значений операнда.

Для ^, значение результата является битовым исключающим "ИЛИ" значений операнда.

Для |, значение результата является поразрядным содержащим ИЛИ значений операнда.

Например, результат выражения 0xff00 & 0xf0f0 0xf000. Результат 0xff00 ^ 0xf0f0 0x0ff0Результат.The 0xff00 | 0xf0f0 0xfff0.

15.21.2 Булевы Логические операторы &, ^, и |

Для &, значение результата true если оба значения операнда true; иначе, результат false.

Для ^, значение результата true если значения операнда отличаются; иначе, результат false.

Для |, значение результата false если оба значения операнда false; иначе, результат true.

15.22 Условных выражений - И Оператор &&

ConditionalAndExpression:

	InclusiveOrExpression

	ConditionalAndExpression && InclusiveOrExpression

Во время выполнения левое выражение операнда оценивается сначала; если его значение false, значение условного выражения - и выражение false и правое выражение операнда не оценивается. Если значение левого операнда true, тогда правое выражение оценивается, и его значение становится значением условного выражения - и выражение. Таким образом, && вычисляет тот же самый результат как & на boolean операнды. Это отличается только по этому, правое выражение операнда оценивается условно, а не всегда.

15.23 Условных выражений - Или Оператор ||

ConditionalOrExpression:

	ConditionalAndExpression

	ConditionalOrExpression || ConditionalAndExpression

Во время выполнения левое выражение операнда оценивается сначала; если его значение true, значение условного выражения - или выражение true и правое выражение операнда не оценивается. Если значение левого операнда false, тогда правое выражение оценивается, и его значение становится значением условного выражения - или выражение. Таким образом, || вычисляет тот же самый результат как | на boolean операнды. Это отличается только по этому, правое выражение операнда оценивается условно, а не всегда.

15.24 Условных Операторов ? :

Условный оператор синтаксически правоассоциативен (это группируется справа налево), так, чтобы a?b:c?d:e?f:g означает то же самое как a?b:(c?d:(e?f:g)).

ConditionalExpression:

	ConditionalOrExpression

	ConditionalOrExpression ? Expression : ConditionalExpression

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

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

Отметьте, что это не разрешается или для второго или для третьего выражения операнда, чтобы быть вызовом a void метод. Фактически, не разрешается для условного выражения появиться в любом контексте где вызов a void метод мог появиться (§14.7).

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

• Если у вторых и третьих операндов есть тот же самый тип (который может быть нулевым типом), то это - тип условного выражения.
• Иначе, если у вторых и третьих операндов есть числовой тип, то есть несколько случаев:
  • Если один из операндов имеет тип byte и другой имеет тип short, тогда тип условного выражения short.
  • Если один из операндов имеет тип T, где T byte, short, или char, и другой операнд является константным выражением типа int чье значение является представимым в типе T, тогда тип условного выражения является T.
  • Иначе, двоичное числовое продвижение (§5.6.2) применяется к типам операнда, и тип условного выражения является продвинутым типом вторых и третьих операндов.
• Если один из вторых и третьих операндов имеет нулевой тип, и тип другого является ссылочным типом, то тип условного выражения является тем ссылочным типом.
• Если вторые и третьи операнды имеют различные ссылочные типы, то должно быть возможно преобразовать один из типов к другому типу (вызовите этот последний тип T) преобразованием присвоения (§5.2); тип условного выражения является T. Это - ошибка времени компиляции, если никакой тип не является присвоением, совместимым с другим типом.

• Если значение первого операнда true, тогда второе выражение операнда выбирается.
• Если значение первого операнда false, тогда третье выражение операнда выбирается.

15.25 Операторов присваивания

AssignmentExpression:

	ConditionalExpression

	Assignment

Assignment:

	LeftHandSide AssignmentOperator AssignmentExpression

LeftHandSide:

	ExpressionName

	FieldAccess

	ArrayAccess

AssignmentOperator: one of

	= *= /= %= += -= <<= >>= >>>= &= ^= |=

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

Переменная, которая объявляется final не может быть присвоен, потому что когда доступ a final переменная используется в качестве выражения, результатом является значение, не переменная, и таким образом, это не может использоваться в качестве операнда оператора присваивания.

15.25.1 Простой Оператор присваивания =

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

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

• Во-первых, ссылочное подвыражение массива левого выражения доступа массива операнда оценивается. Если эта оценка завершается резко, то выражение присвоения завершается резко по той же самой причине; индексное подвыражение (левого выражения доступа массива операнда) и правый операнд не оценивается, и никакое присвоение не происходит.
• Иначе, индексное подвыражение левого выражения доступа массива операнда оценивается. Если эта оценка завершается резко, то выражение присвоения завершается резко по той же самой причине, и правый операнд не оценивается, и никакое присвоение не происходит.
• Иначе, правый операнд оценивается. Если эта оценка завершается резко, то выражение присвоения завершается резко по той же самой причине, и никакое присвоение не происходит.
• Иначе, если значение ссылочного подвыражения массива null, тогда никакое присвоение не происходит и a NullPointerException бросается.
• Иначе, значение ссылочного подвыражения массива действительно обращается к массиву. Если значение индексного подвыражения является меньше чем нуль, или больше чем или равный длине массива, то никакое присвоение не происходит и IndexOutOfBoundsException бросается.
• Иначе, значение индексного подвыражения используется, чтобы выбрать компонент массива, упомянутого значением ссылочного подвыражения массива. Этот компонент является переменной; вызовите его SC типа. Кроме того, позвольте TC быть типом левого операнда оператора присваивания как определено во время компиляции.
  • Если TC является типом примитива, то SC является обязательно тем же самым как TC. Значение правого операнда преобразовывается в значение TC типа и сохранено в выбранный компонент массива.
  • Если T является ссылочным типом, то SC, возможно, не то же самое как T, а скорее тип, который расширяет или реализует TC. Позвольте RC быть классом объекта, упомянутого значением правого операнда во время выполнения.
  • Компилятор может быть в состоянии доказать во время компиляции, что компонент массива будет иметь TC типа точно (например, TC мог бы быть final). Но если компилятор не может доказать во время компиляции, что компонент массива будет иметь TC типа точно, затем проверка должна быть выполнена во время выполнения, чтобы гарантировать, что RC класса является присвоением, совместимым (§5.2) с фактическим SC типа компонента массива. Эта проверка подобна броску сужения (§5.4, §15.15), за исключением того, что, если проверка перестала работать, ArrayStoreException бросается, а не a ClassCastException. Поэтому:
    • Если RC класса не присваиваем, чтобы ввести SC, то никакое присвоение не происходит и ArrayStoreException бросается.
    • Иначе, ссылочное значение правого операнда сохранено в выбранный компонент массива.

class ArrayReferenceThrow extends RuntimeException { }


class IndexThrow extends RuntimeException { }


class RightHandSideThrow extends RuntimeException { }

class IllustrateSimpleArrayAssignment {

	static Object[] objects = { new Object(), new Object() };


	static Thread[] threads = { new Thread(), new Thread() };


	static Object[] arrayThrow() {
		throw new ArrayReferenceThrow();
	}


	static int indexThrow() { throw new IndexThrow(); }


	static Thread rightThrow() {
		throw new RightHandSideThrow();
	}


	static String name(Object q) {
		String sq = q.getClass().getName();
		int k = sq.lastIndexOf('.');
		return (k < 0) ? sq : sq.substring(k+1);
	}


	static void testFour(Object[] x, int j, Object y) {
		String sx = x == null ? "null" : name(x[0]) + "s";
		String sy = name(y);
		System.out.println();
		try {
			System.out.print(sx + "[throw]=throw => ");
			x[indexThrow()] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[throw]=" + sy + " => ");
			x[indexThrow()] = y;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]=throw => ");
			x[j] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]=" + sy + " => ");
			x[j] = y;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
	}


	public static void main(String[] args) {
		try {
			System.out.print("throw[throw]=throw => ");
			arrayThrow()[indexThrow()] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[throw]=Thread => ");
			arrayThrow()[indexThrow()] = new Thread();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]=throw => ");
			arrayThrow()[1] = rightThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]=Thread => ");
			arrayThrow()[1] = new Thread();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		testFour(null, 1, new StringBuffer());
		testFour(null, 1, new StringBuffer());
		testFour(null, 9, new Thread());
		testFour(null, 9, new Thread());
		testFour(objects, 1, new StringBuffer());
		testFour(objects, 1, new Thread());
		testFour(objects, 9, new StringBuffer());
		testFour(objects, 9, new Thread());
		testFour(threads, 1, new StringBuffer());
		testFour(threads, 1, new Thread());
		testFour(threads, 9, new StringBuffer());
		testFour(threads, 9, new Thread());
	}

}

throw[throw]=throw => ArrayReferenceThrow
throw[throw]=Thread => ArrayReferenceThrow
throw[1]=throw => ArrayReferenceThrow
throw[1]=Thread => ArrayReferenceThrow


null[throw]=throw => IndexThrow
null[throw]=StringBuffer => IndexThrow
null[1]=throw => RightHandSideThrow
null[1]=StringBuffer => NullPointerException


null[throw]=throw => IndexThrow
null[throw]=StringBuffer => IndexThrow
null[1]=throw => RightHandSideThrow
null[1]=StringBuffer => NullPointerException


null[throw]=throw => IndexThrow
null[throw]=Thread => IndexThrow
null[9]=throw => RightHandSideThrow
null[9]=Thread => NullPointerException


null[throw]=throw => IndexThrow
null[throw]=Thread => IndexThrow
null[9]=throw => RightHandSideThrow
null[9]=Thread => NullPointerException


Objects[throw]=throw => IndexThrow
Objects[throw]=StringBuffer => IndexThrow
Objects[1]=throw => RightHandSideThrow
Objects[1]=StringBuffer => Okay!


Objects[throw]=throw => IndexThrow
Objects[throw]=Thread => IndexThrow
Objects[1]=throw => RightHandSideThrow
Objects[1]=Thread => Okay!


Objects[throw]=throw => IndexThrow
Objects[throw]=StringBuffer => IndexThrow
Objects[9]=throw => RightHandSideThrow
Objects[9]=StringBuffer => IndexOutOfBoundsException


Objects[throw]=throw => IndexThrow
Objects[throw]=Thread => IndexThrow
Objects[9]=throw => RightHandSideThrow
Objects[9]=Thread => IndexOutOfBoundsException


Threads[throw]=throw => IndexThrow
Threads[throw]=StringBuffer => IndexThrow
Threads[1]=throw => RightHandSideThrow
Threads[1]=StringBuffer => ArrayStoreException


Threads[throw]=throw => IndexThrow
Threads[throw]=Thread => IndexThrow
Threads[1]=throw => RightHandSideThrow
Threads[1]=Thread => Okay!


Threads[throw]=throw => IndexThrow
Threads[throw]=StringBuffer => IndexThrow
Threads[9]=throw => RightHandSideThrow
Threads[9]=StringBuffer => IndexOutOfBoundsException


Threads[throw]=throw => IndexThrow
Threads[throw]=Thread => IndexThrow
Threads[9]=throw => RightHandSideThrow
Threads[9]=Thread => IndexOutOfBoundsException

Threads[1]=StringBuffer => ArrayStoreException

15.25.2 Составные Операторы присваивания

Составное выражение присвоения формы E1 op = E2 эквивалентно E1 = (T)((E1) op (E2)), где T является типом E1, за исключением того, что E1 оценивается только однажды. Отметьте, что подразумеваемый бросок к типу T может быть или преобразованием идентификационных данных (§5.1.1) или сужающимся примитивным преобразованием (§5.1.3). Например, следующий код корректен:

short x = 3;
x += 4.6;

short x = 3;
x = (short)(x + 4.6);

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

• Во-первых, ссылочное подвыражение массива левого выражения доступа массива операнда оценивается. Если эта оценка завершается резко, то выражение присвоения завершается резко по той же самой причине; индексное подвыражение (левого выражения доступа массива операнда) и правый операнд не оценивается, и никакое присвоение не происходит.
• Иначе, индексное подвыражение левого выражения доступа массива операнда оценивается. Если эта оценка завершается резко, то выражение присвоения завершается резко по той же самой причине, и правый операнд не оценивается, и никакое присвоение не происходит.
• Иначе, если значение ссылочного подвыражения массива null, тогда никакое присвоение не происходит и a NullPointerException бросается.
• Иначе, значение ссылочного подвыражения массива действительно обращается к массиву. Если значение индексного подвыражения является меньше чем нуль, или больше чем или равный длине массива, то никакое присвоение не происходит и IndexOutOfBoundsException бросается.
• Иначе, значение индексного подвыражения используется, чтобы выбрать компонент массива, упомянутого значением ссылочного подвыражения массива. Значение этого компонента сохраняется, и затем правый операнд оценивается. Если эта оценка завершается резко, то выражение присвоения завершается резко по той же самой причине, и никакое присвоение не происходит. (Для простого оператора присваивания происходит оценка правого операнда перед проверками ссылочного подвыражения массива и индексного подвыражения, но для составного оператора присваивания, оценка правого операнда происходит после этих проверок.)
• Иначе, считайте компонент массива выбранным в предыдущем шаге, значение которого было сохранено. Этот компонент является переменной; вызовите его тип S. Кроме того, позвольте T быть типом левого операнда оператора присваивания как определено во время компиляции.
  • Если T является типом примитива, то S является обязательно тем же самым как T.
    • Сохраненное значение компонента массива и значение правого операнда используются, чтобы выполнить бинарную операцию, обозначенную составным оператором присваивания. Если эта работа завершается резко (единственная возможность является целочисленным делением на нуль - видят §15.16.2), то выражение присвоения завершается резко по той же самой причине, и никакое присвоение не происходит.
    • Иначе, результат бинарной операции преобразовывается в тип компонента массива, и результат преобразования сохранен в компонент массива.
  • Если T является ссылочным типом, то это должно быть String. Поскольку класс String a final класс, S должен также быть String. Поэтому проверка на этапе выполнения, которая иногда требуется для простого оператора присваивания, никогда не требуется для составного оператора присваивания.
    • Сохраненное значение компонента массива и значение правого операнда используются, чтобы выполнить бинарную операцию (конкатенация строк), обозначенная составным оператором присваивания (который является обязательно +=). Если эта работа завершается резко, то выражение присвоения завершается резко по той же самой причине, и никакое присвоение не происходит.
    • Иначе, String результат бинарной операции сохранен в компонент массива.

class ArrayReferenceThrow extends RuntimeException { }


class IndexThrow extends RuntimeException { }


class RightHandSideThrow extends RuntimeException { }

class IllustrateCompoundArrayAssignment {

	static String[] strings = { "Simon", "Garfunkel" };


	static double[] doubles = { Math.E, Math.PI };

	static String[] stringsThrow() {
		throw new ArrayReferenceThrow();
	}


	static double[] doublesThrow() {
		throw new ArrayReferenceThrow();
	}


	static int indexThrow() { throw new IndexThrow(); }


	static String stringThrow() {
		throw new RightHandSideThrow();
	}


	static double doubleThrow() {
		throw new RightHandSideThrow();
	}


	static String name(Object q) {
		String sq = q.getClass().getName();
		int k = sq.lastIndexOf('.');
		return (k < 0) ? sq : sq.substring(k+1);
	}


	static void testEight(String[] x, double[] z, int j) {
		String sx = (x == null) ? "null" : "Strings";
		String sz = (z == null) ? "null" : "doubles";
		System.out.println();
		try {
			System.out.print(sx + "[throw]+=throw => ");
			x[indexThrow()] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[throw]+=throw => ");
			z[indexThrow()] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		try {
			System.out.print(sx + "[throw]+=\"heh\" => ");
			x[indexThrow()] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[throw]+=12345 => ");
			z[indexThrow()] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]+=throw => ");
			x[j] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[" + j + "]+=throw => ");
			z[j] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sx + "[" + j + "]+=\"heh\" => ");
			x[j] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print(sz + "[" + j + "]+=12345 => ");
			z[j] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
	}


	public static void main(String[] args) {
		try {
			System.out.print("throw[throw]+=throw => ");
			stringsThrow()[indexThrow()] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[throw]+=throw => ");
			doublesThrow()[indexThrow()] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[throw]+=\"heh\" => ");
			stringsThrow()[indexThrow()] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		try {
			System.out.print("throw[throw]+=12345 => ");
			doublesThrow()[indexThrow()] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=throw => ");
			stringsThrow()[1] += stringThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=throw => ");
			doublesThrow()[1] += doubleThrow();
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=\"heh\" => ");
			stringsThrow()[1] += "heh";
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }
		try {
			System.out.print("throw[1]+=12345 => ");
			doublesThrow()[1] += 12345;
			System.out.println("Okay!");
		} catch (Throwable e) { System.out.println(name(e)); }

		testEight(null, null, 1);
		testEight(null, null, 9);
		testEight(strings, doubles, 1);
		testEight(strings, doubles, 9);
	}

}

throw[throw]+=throw => ArrayReferenceThrow
throw[throw]+=throw => ArrayReferenceThrow
throw[throw]+="heh" => ArrayReferenceThrow
throw[throw]+=12345 => ArrayReferenceThrow
throw[1]+=throw => ArrayReferenceThrow
throw[1]+=throw => ArrayReferenceThrow
throw[1]+="heh" => ArrayReferenceThrow
throw[1]+=12345 => ArrayReferenceThrow


null[throw]+=throw => IndexThrow
null[throw]+=throw => IndexThrow
null[throw]+="heh" => IndexThrow
null[throw]+=12345 => IndexThrow
null[1]+=throw => NullPointerException
null[1]+=throw => NullPointerException
null[1]+="heh" => NullPointerException
null[1]+=12345 => NullPointerException


null[throw]+=throw => IndexThrow
null[throw]+=throw => IndexThrow
null[throw]+="heh" => IndexThrow
null[throw]+=12345 => IndexThrow
null[9]+=throw => NullPointerException
null[9]+=throw => NullPointerException
null[9]+="heh" => NullPointerException
null[9]+=12345 => NullPointerException


Strings[throw]+=throw => IndexThrow
doubles[throw]+=throw => IndexThrow
Strings[throw]+="heh" => IndexThrow
doubles[throw]+=12345 => IndexThrow
Strings[1]+=throw => RightHandSideThrow
doubles[1]+=throw => RightHandSideThrow
Strings[1]+="heh" => Okay!
doubles[1]+=12345 => Okay!


Strings[throw]+=throw => IndexThrow
doubles[throw]+=throw => IndexThrow
Strings[throw]+="heh" => IndexThrow
doubles[throw]+=12345 => IndexThrow
Strings[9]+=throw => IndexOutOfBoundsException
doubles[9]+=throw => IndexOutOfBoundsException
Strings[9]+="heh" => IndexOutOfBoundsException
doubles[9]+=12345 => IndexOutOfBoundsException

Strings[1]+=throw => RightHandSideThrow
doubles[1]+=throw => RightHandSideThrow

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

class Test {
	public static void main(String[] args) {
		int k = 1;
		int[] a = { 1 };
		k += (k = 4) * (k + 2);
		a[0] += (a[0] = 4) * (a[0] + 2);
		System.out.println("k==" + k + " and a[0]==" + a[0]);
	}
}

k==25 and a[0]==25

k += (k = 4) * (k + 2);
a[0] += (a[0] = 4) * (a[0] + 2);

k = k + (k = 4) * (k + 2);
a[0] = a[0] + (a[0] = 4) * (a[0] + 2);

15.26 Выражений

Expression:

	AssignmentExpression

15.27 Константных выражений

ConstantExpression:

	Expression

• Литералы типа примитива и литералы типа String
• Броски к типам примитивов и броски, чтобы ввести String
• Унарные операторы +, -, ~, и ! (но нет ++ или --)
• Мультипликативные операторы *, /, и %
• Аддитивные операторы + и -
• Операторы сдвига <<, >>, и >>>
• Операторы отношения <, <=, >, и >= (но нет instanceof)
• Операторы равенства == и !=
• Логические операторы и логические операторы &, ^, и |
• Условное выражение - и оператор && и условное выражение - или оператор ||
• Троичный условный оператор ? :
• Простые имена, которые обращаются к final переменные, инициализаторы которых являются константными выражениями
• Полностью определенные имена формы TypeName . Идентификатор, которые обращаются к final переменные, инициализаторы которых являются константными выражениями

Примеры константных выражений:

true
(short)(1*2*3*4*5*6)
Integer.MAX_VALUE / 2
2.0 * Math.PI
"The integer " + Long.MAX_VALUE + " is mighty big."

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

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