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

ГЛАВА 4

Типы, Значения, и Переменные

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

Типы языка Java делятся на две категории: типы примитивов и ссылочные типы. Типы примитивов (§4.2) boolean введите и числовые типы. Числовые типы являются целочисленными типами byte, short, int, long, и char, и типы с плавающей точкой float и double. Ссылочные типы (§4.3) являются типами классов, интерфейсными типами, и выстраивают типы. Есть также специальный нулевой тип. Объект (§4.3.1) в Java является динамически создаваемым экземпляром типа класса или динамически создаваемым массивом. Значения ссылочного типа являются ссылками на объекты. Все объекты, включая массивы, поддерживают методы класса Object (§4.3.2). Строковые литералы представляются String объекты (§4.3.3).

Типы - тот же самый (§4.3.4), если они имеют те же самые полностью определенные имена и загружаются тем же самым загрузчиком класса. Имена типов используются (§4.4) в объявлениях, в бросках, в выражениях создания экземпляра класса, в выражениях создания массива, и в instanceof выражения оператора.

Переменная (§4.5) является местом хранения. Переменная типа примитива всегда содержит значение того точного типа. Переменная типа класса T может содержать нулевую ссылку или ссылку на экземпляр класса T или любого класса, который является подклассом T. Переменная интерфейсного типа может содержать нулевую ссылку или ссылку на любой экземпляр любого класса, который реализует интерфейс. Если T является типом примитива, то переменная типа "массив T" может содержать нулевую ссылку или ссылку на любой массив типа "массив T"; если T является ссылочным типом, то переменная типа "массив T" может содержать нулевую ссылку или ссылку на любой массив типа "массив S" так, что, тип S присваиваем (§5.2) типу T. Переменная типа Object может содержать нулевую ссылку или ссылку на любой объект, ли экземпляр класса или массив.

4.1 Виды Типов и Значений

Type:

	PrimitiveType

	ReferenceType

4.2 Типы примитивов и Значения

PrimitiveType:

	NumericType

	boolean

NumericType:

	IntegralType

	FloatingPointType

IntegralType: one of

	byte short int long char

FloatingPointType: one of

	float double

Числовые типы являются целочисленными типами и типами с плавающей точкой.

Целочисленные типы byte, short, int, и long, чьи значения являются 8-разрядными, 16-разрядными, 32-разрядными и 64-разрядными two's-дополнительными целыми числами со знаком, соответственно, и char, чьи значения являются 16-разрядными целыми без знака, представляющими символы Unicode.

Типы с плавающей точкой float, чьи значения являются 32-разрядным IEEE 754 числа с плавающей точкой, и double, чьи значения являются 64-разрядным IEEE 754 числа с плавающей точкой.

boolean у типа есть точно два значения: true и false.

4.2.1 Целочисленные типы и Значения

• Для byte, от-128 до 127, включительно
• Для short, от-32768 до 32767, включительно
• Для int, от-2147483648 до 2147483647, включительно
• Для long, от-9223372036854775808 до 9223372036854775807, включительно
• Для char, от '\u0000' к '\uffff' включительно, то есть, от 0 до 65535

4.2.2 Целочисленные операции

• Операторы сравнения, которые приводят к значению типа boolean:
  • Числовые операторы сравнения <, <=, >, и >= (§15.19.1)
  • Числовые операторы равенства == и != (§15.20.1)
• Числовые операторы, которые приводят к значению типа int или long:
  • Унарное плюс и минус операторы + и - (§15.14.3, §15.14.4)
  • Мультипликативные операторы *, /, и % (§15.16)
  • Аддитивные операторы + и - (§15.17.2)
  • Инкрементный оператор ++, и префикс (§15.14.1) и постфикс (§15.13.2)
  • Декрементный оператор --, и префикс (§15.14.2) и постфикс (§15.13.3)
  • Операторы сдвига без знака и со знаком <<, >>, и >>> (§15.18)
  • Поразрядный дополнительный оператор ~ (§15.14.5)
  • Целочисленные логические операторы &, |, и ^ (§15.21.1)
• Условный оператор ? : (§15.24)
• Оператор броска, который может преобразовать от интегрального значения до значения любого указанного числового типа (§5.4, §15.15)
• Оператор конкатенации строк + (§15.17.1), который, когда дано a String операнд и интегральный операнд, преобразует интегральный операнд в a String представление его значения в десятичной форме, и затем производит недавно создаваемый String это - связь двух строк

Если у целочисленного оператора кроме оператора сдвига есть по крайней мере один операнд типа long, тогда работа выполняется, используя 64-разрядную точность, и результат числового оператора имеет тип long. Если другой операнд не long, это сначала расширяется (§5.1.2), чтобы ввести long числовым продвижением (§5.6). Иначе, работа выполняется, используя 32-разрядную точность, и результат числового оператора имеет тип int. Если любой операнд не int, это сначала расширяется до типа int числовым продвижением.

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

Пример:

class Test {
	public static void main(String[] args) {
		int i = 1000000;
		System.out.println(i * i);
		long l = i;
		System.out.println(l * l);
		System.out.println(20296 / (l - i));
	}
}

-727379968
1000000000000

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

4.2.3 Типы с плавающей точкой и Значения

Стандарт IEEE 754 включает не только положительный и числа величины знака минус, но также и положительные и отрицательные нули, положительные и отрицательные бесконечности, и специальное Не-число (после этого сокращал НЭН). Значение НЭН используется, чтобы представить результат определенных операций, таких как делящийся нуль нулем. Константы НЭН обоих float и double тип предопределяется как Float.NaN (§20.9.5) и Double.NaN (§20.10.5).

Конечные ненулевые значения типа float имеют форму, где s +1 или-1, м. является положительным целым числом меньше чем, и e является целым числом между-149 и 104, включительно. Значения той формы так, что м. положителен, но меньше чем, и e равен-149, как, говорят, денормализовываются.

Конечные ненулевые значения типа double имеют форму, где s +1 или-1, м. является положительным целым числом меньше чем, и e является целым числом между-1075 и 970, включительно. Значения той формы так, что м. положителен, но меньше чем, и e равен-1075, как, говорят, денормализовываются.

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

Положительный нулевой и отрицательный нуль сравнивается равный; таким образом результат выражения 0.0==-0.0 true и результат 0.0>-0.0 false. Но другие операции могут отличить положительный и отрицательный нуль; например, 1.0/0.0 имеет значение положительная бесконечность, в то время как значение 1.0/-0.0 отрицательная бесконечность. Операции Math.min и Math.max также отличите положительный нулевой и отрицательный нуль.

НЭН неупорядочивают, таким образом, числовые операторы сравнения <, <=, >, и >= возвратиться false если или или оба операнда НЭН (§15.19.1). Оператор равенства == возвраты false если любым операндом является НЭН, и оператор неравенства != возвраты true если любым операндом является НЭН (§15.20.1). В частности x!=x true если и только если x НЭН, и (x<y) == !(x>=y) будет false если x или y НЭН.

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

4.2.4 Операции с плавающей точкой

• Операторы сравнения, которые приводят к значению типа boolean:
  • Числовые операторы сравнения <, <=, >, и >= (§15.19.1)
  • Числовые операторы равенства == и != (§15.20.1)
• Числовые операторы, которые приводят к значению типа float или double:
  • Унарное плюс и минус операторы + и - (§15.14.3, §15.14.4)
  • Мультипликативные операторы *, /, и % (§15.16)
  • Аддитивные операторы + и - (§15.17.2)
  • Инкрементный оператор ++, и префикс (§15.14.1) и постфикс (§15.13.2)
  • Декрементный оператор --, и префикс (§15.14.2) и постфикс (§15.13.3)
• Условный оператор ? : (§15.24)
• Оператор броска, который может преобразовать от значения с плавающей точкой до значения любого указанного числового типа (§5.4, §15.15)
• Оператор конкатенации строк + (§15.17.1), который, когда дано a String операнд и операнд с плавающей точкой, преобразует операнд с плавающей точкой в a String представление его значения в десятичной форме (без информационной потери), и затем производит недавно создаваемый String связывая две строки

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

Если по крайней мере один из операндов числовому оператору имеет тип double, тогда работа выполняется, используя 64-разрядную арифметику с плавающей точкой, и результатом числового оператора является значение типа double. (Если другой операнд не является a double, это сначала расширяется до типа double числовым продвижением (§5.6).) Иначе, работа выполняется, используя 32-разрядную арифметику с плавающей точкой, и результатом числового оператора является значение типа float. Если другой операнд не является a float, это сначала расширяется до типа float числовым продвижением.

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

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

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

Java операторы с плавающей точкой не производит исключений (§11). Работа, которая переполнения производят бесконечность со знаком, работа, которая потери значимости производят нуль со знаком, и работа, у которой нет никакого математически определенного результата, производит НЭН. Все числовые операции с НЭН как операнд производят НЭН в результате. Как был уже описан, НЭН неупорядочивают, таким образом, числовая работа сравнения, включающая один или два возврата NaNs false и любой != сравнение, включающее возвраты НЭН true, включая x!=x когда x НЭН.

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

class Test {

	public static void main(String[] args) {

		// An example of overflow:
		double d = 1e308;
		System.out.print("overflow produces infinity: ");
		System.out.println(d + "*10==" + d*10);

		// An example of gradual underflow:
		d = 1e-305 * Math.PI;
		System.out.print("gradual underflow: " + d + "\n      ");
		for (int i = 0; i < 4; i++)
			System.out.print(" " + (d /= 100000));
		System.out.println();

		// An example of NaN:
		System.out.print("0.0/0.0 is Not-a-Number: ");
		d = 0.0/0.0;
		System.out.println(d);

		// An example of inexact results and rounding:
		System.out.print("inexact results with float:");
		for (int i = 0; i < 100; i++) {
			float z = 1.0f / i;
			if (z * i != 1.0f)
				System.out.print(" " + i);
		}
		System.out.println();

		// Another example of inexact results and rounding:
		System.out.print("inexact results with double:");
		for (int i = 0; i < 100; i++) {
			double z = 1.0 / i;
			if (z * i != 1.0)
				System.out.print(" " + i);
		}
		System.out.println();

		// An example of cast to integer rounding:
		System.out.print("cast to int rounds toward 0: ");
		d = 12345.6;
		System.out.println((int)d + " " + (int)(-d));
	}
}

overflow produces infinity: 1.0e+308*10==Infinity
gradual underflow: 3.141592653589793E-305
	3.1415926535898E-310 3.141592653E-315 3.142E-320 0.0
0.0/0.0 is Not-a-Number: NaN
inexact results with float: 0 41 47 55 61 82 83 94 97
inexact results with double: 0 49 98
cast to int rounds toward 0: 12345 -12345

Неточные результаты, когда i 0 включите подразделение нулем, так, чтобы z становится положительной бесконечностью, и z * 0 НЭН, которая не равна 1.0.

4.2.5 boolean Введите и boolean Значения

• Операторы отношения == и != (§15.20.2)
• Логически-дополнительный оператор ! (§15.14.6)
• Логические операторы &, ^, и | (§15.21.2)
• Условное выражение - и и условное выражение - или операторы && (§15.22) и || (§15.23)
• Условный оператор ? : (§15.24)
• Оператор конкатенации строк + (§15.17.1), который, когда дано a String операнд и булев операнд, преобразует булев операнд в a String (также "true" или "false"), и затем произведите недавно создаваемый String это - связь двух строк

• if оператор (§14.8)
• while оператор (§14.10)
• do оператор (§14.11)
• for оператор (§14.12)

Только boolean выражения могут использоваться в операторах управления и как первый операнд условного оператора ? :. Целое число x может быть преобразован в a boolean, после соглашения языка C, которое любое ненулевое значение true, по выражению x!=0. Ссылка на объект obj может быть преобразован в a boolean, после соглашения языка C, что любая ссылка кроме null true, по выражению obj!=null.

Бросок a boolean оцените типу boolean позволяется (§5.1.1); никто другой не набирает тип boolean позволяются. A boolean может быть преобразован в строку преобразованием строк (§5.4).

4.3 Ссылочные типы и Значения

ReferenceType:

	ClassOrInterfaceType

	ArrayType

ClassOrInterfaceType:

	ClassType

	InterfaceType

ClassType:

	TypeName

InterfaceType:

	TypeName

ArrayType:

	Type [ ]

Пример кода:

class Point { int[] metrics; }

interface Move { void move(int deltax, int deltay); }

4.3.1 Объекты

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

Экземпляр класса явно создается выражением создания экземпляра класса (§15.8), или вызывая newInstance метод класса Class (§20.3.8). Массив явно создается выражением создания массива (§15.8).

Новый экземпляр класса неявно создается, когда оператор конкатенации строк + (§15.17.1) используется в выражении, приводящем к новому объекту типа String (§4.3.3, §20.12). Новый объект массива неявно создается, когда выражение инициализатора массива (§10.6) оценивается; это может произойти, когда класс или интерфейс инициализируются (§12.4), когда новый экземпляр класса создается (§15.8), или когда оператор объявления локальной переменной выполняется (§14.3).

Многие из этих случаев иллюстрируются в следующем примере:

class Point {
	int x, y;
	Point() { System.out.println("default"); }
	Point(int x, int y) { this.x = x; this.y = y; }

	// A Point instance is explicitly created at class initialization time:
	static Point origin = new Point(0,0);

	// A String can be implicitly created by a + operator:
	public String toString() {

		return "(" + x + "," + y + ")";

	}
}


class Test {
	public static void main(String[] args) {
		// A Point is explicitly created using newInstance:
		Point p = null;
		try {
			p = (Point)Class.forName("Point").newInstance();
		} catch (Exception e) {
			System.out.println(e);
		}


		// An array is implicitly created by an array constructor:
		Point a[] = { new Point(0,0), new Point(1,1) };


		// Strings are implicitly created by + operators:
		System.out.println("p: " + p);
		System.out.println("a: { " + a[0] + ", "

										   + a[1] + " }");


		// An array is explicitly created by an array creation expression:
		String sa[] = new String[2];
		sa[0] = "he"; sa[1] = "llo";
		System.out.println(sa[0] + sa[1]);
	}
}

default
p: (0,0)
a: { (0,0), (1,1) }
hello

• Доступ к полю, используя или полностью определенное имя (§6.6) или выражение доступа к полю (§15.10)
• Вызов метода (§15.11)
• Оператор броска (§5.4, §15.15)
• Оператор конкатенации строк + (§15.17.1), который, когда дано a String операнд и ссылка, преобразует ссылку на a String вызывая toString метод (§20.1.2) объекта, на который ссылаются (использование "null" если или ссылка или результат toString нулевая ссылка), и затем произведет недавно создаваемый String это - связь двух строк
• instanceof оператор (§15.19.2)
• Ссылочные операторы равенства == и != (§15.20.3)
• Условный оператор ? : (§15.24).

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

class Value { int val; }

class Test {
	public static void main(String[] args) {
		int i1 = 3;
		int i2 = i1;
		i2 = 4;
		System.out.print("i1==" + i1);
		System.out.println(" but i2==" + i2);
		Value v1 = new Value();
		v1.val = 5;
		Value v2 = v1;
		v2.val = 6;
		System.out.print("v1.val==" + v1.val);
		System.out.println(" and v2.val==" + v2.val);
	}
}

i1==3 but i2==4
v1.val==6 and v2.val==6

См. §10 и §15.9 для примеров создания и использования массивов.

У каждого объекта есть связанная блокировка (§17.13), который используется synchronized методы (§8.4.3) и synchronized оператор (§14.17), чтобы обеспечить управление параллельным доступом, чтобы утвердить многократными потоками (§17.12, §20.20).

4.3.2 Класс Object

package java.lang;

public class Object {
	public final Class getClass() { . . . }
	public String toString() { . . . }
	public boolean equals(Object obj) { . . . }
	public int hashCode() { . . . }
	protected Object clone()
		throws CloneNotSupportedException { . . . }
	public final void wait()

		throws IllegalMonitorStateException,

			InterruptedException { . . . }
	public final void wait(long millis)
		throws IllegalMonitorStateException,
			InterruptedException { . . . }
	public final void wait(long millis, int nanos) { . . . }
		throws IllegalMonitorStateException,
			InterruptedException { . . . }
	public final void notify() { . . . }
		throws IllegalMonitorStateException
	public final void notifyAll() { . . . }
		throws IllegalMonitorStateException
	protected void finalize()
		throws Throwable { . . . }
}

• Метод getClass возвраты Class объект (§20.3), который представляет класс объекта. A Class объект существует для каждого ссылочного типа. Это может использоваться, например, чтобы обнаружить полностью определенное имя класса, его элементов, его непосредственного суперкласса, и любых интерфейсов, которые это реализует. Метод класса, который объявляется synchronized (§8.4.3.5) синхронизируется на блокировке, связанной с Class объект класса.
• Метод toString возвраты a String представление объекта.
• Методы equals и hashCode объявляются в пользу хеш-таблиц таким как java.util.Hashtable (§21.7). Метод equals определяет понятие объектного равенства, которое основано на значении, не ссылке, сравнении.
• Метод clone используется, чтобы сделать копию объекта.
• Методы wait, notify, и notifyAll используются в параллельном программировании, используя потоки, как описано в §17.
• Метод finalize выполняется непосредственно перед тем, как объект уничтожается и описывается в §12.6.

4.3.3 Класс String

Оператор конкатенации строк + (§15.17.1) неявно создает новое String объект.

4.3.4 Когда Ссылочные типы Являются Тем же самым

• Они - оба класс или оба интерфейсных типа, загружаются тем же самым загрузчиком класса, и имеют то же самое полностью определенное имя (§6.6), когда они, как иногда говорят, являются тем же самым классом или тем же самым интерфейсом.
• Они - и типы массива, и имеют тот же самый компонентный тип (§10).

4.4 Где Типы Используются

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

import java.util.Random;

class MiscMath {

	int divisor;


	MiscMath(int divisor) {
		this.divisor = divisor;
	}


	float ratio(long l) {
		try {
			l /= divisor;
		} catch (Exception e) {
			if (e instanceof ArithmeticException)
				l = Long.MAX_VALUE;
			else
				l = 0;
		}
		return (float)l;
	}


	double gausser() {
		Random r = new Random();
		double[] val = new double[2];
		val[0] = r.nextGaussian();
		val[1] = r.nextGaussian();
		return (val[0] + val[1]) / 2;
	}

}

• Импортированные типы (§7.5); здесь тип Random, импортированный из типа java.util.Random из пакета java.util, объявляется
• Поля, которые являются переменными класса и переменными экземпляра классов (§8.3), и константы интерфейсов (§9.3); здесь поле divisor в классе MiscMath как объявляют, имеет тип int
• Параметры метода (§8.4.1); здесь параметр l из метода ratio как объявляют, имеет тип long
• Результаты метода (§8.4); здесь результат метода ratio как объявляют, имеет тип float, и результат метода gausser как объявляют, имеет тип double
• Параметры конструктора (§8.6.1); здесь параметр конструктора для MiscMath как объявляют, имеет тип int
• Локальные переменные (§14.3, §14.12); локальные переменные r и val из метода gausser как объявляют, имеют типы Random и double[] (массив double)
• Параметры обработчика исключений (§14.18); здесь параметр обработчика исключений e из catch пункт, как объявляют, имеет тип Exception

• Создания экземпляра класса (§15.8); здесь локальная переменная r из метода gausser инициализируется выражением создания экземпляра класса, которое использует тип Random
• Создания массива (§15.9); здесь локальная переменная val из метода gausser инициализируется выражением создания массива, которое создает массив double с размером 2
• Броски (§15.15); здесь return оператор метода ratio использование float введите бросок
• instanceof оператор (§15.19.2); здесь instanceof оператор тестирует ли e присвоение, совместимое с типом ArithmeticException

4.5 Переменные

Совместимость значения переменной с ее типом гарантируется проектом языка Java. Значения по умолчанию являются совместимыми (§4.5.4), и все присвоения на переменную проверяются на совместимость присвоения (§5.2), обычно во время компиляции, но, в единственных массивах включения случая, проверка на этапе выполнения делается (§10.10).

4.5.1 Переменные Типа примитива

4.5.2 Переменные Ссылочного типа

• Нулевая ссылка
• Ссылка на любой объект (§4.3), чей класс (§4.5.5) является присвоением, совместимым (§5.2) с типом переменной

4.5.3 Виды Переменных

1. Переменная класса является полем, объявил использование ключевого слова static в пределах объявления класса (§8.3.1.1), или с или без ключевого слова static в пределах интерфейсного объявления (§9.3). Переменная класса создается, когда ее класс или интерфейс загружаются (§12.2) и инициализируются к значению по умолчанию (§4.5.4). Переменная класса эффективно прекращает существование, когда ее класс или интерфейс разгружаются (§12.8), после того, как любое необходимое завершение класса или интерфейса (§12.6) был завершен.
2. Переменная экземпляра является полем, объявленным в пределах объявления класса, не используя ключевое слово static (§8.3.1.1). Если класс T имеет поле a, которое является переменной экземпляра, затем новая переменная экземпляра создаваемого и инициализированного к значению по умолчанию (§4.5.4) как часть каждого недавно создаваемого объекта класса T или любого класса, который является подклассом T (§8.1.3). Переменная экземпляра эффективно прекращает существование, когда, объектом которого это - поле, больше не ссылается, после любого необходимого завершения объекта был завершен (§12.6).
3. Компоненты массива являются неназванными переменными, которые создаются и инициализируются к значениям по умолчанию (§4.5.4) всякий раз, когда новый объект, который является массивом, создается (§15.9). Компоненты массива эффективно прекращают существование, когда на массив больше не ссылаются. См. §10 для описания массивов.
4. Параметры метода (§8.4.1) называют значения аргументов переданными к методу. Для каждого параметра, объявленного в объявлении метода, новая переменная параметра создается каждый раз, когда метод вызывается (§15.11). Новая переменная инициализируется с соответствующим значением аргумента от вызова метода. Параметр метода эффективно прекращает существование, когда выполнение тела метода полно.
5. Параметры конструктора (§8.6.1) называют значения аргументов переданными конструктору. Для каждого параметра, объявленного в объявлении конструктора, новая переменная параметра создается каждый раз, когда выражение создания экземпляра класса (§15.8) или явный вызов конструктора (§8.6.5) вызывает того конструктора. Новая переменная инициализируется с соответствующим значением аргумента от выражения создания или вызова конструктора. Параметр конструктора эффективно прекращает существование, когда выполнение тела конструктора полно.
6. Параметр обработчика исключений создается каждый раз, когда исключение поймано a catch пункт a try оператор (§14.18). Новая переменная инициализируется с фактическим объектом, связанным с исключением (§11.3, §14.16). Параметр обработчика исключений эффективно прекращает существование когда выполнение блока, связанного с catch пункт полон.
7. Локальные переменные объявляются операторами объявления локальной переменной (§14.3). Всякий раз, когда поток управления вводит блок (§14.2) или for оператор (§14.12), новая переменная создается для каждой локальной переменной, объявленной в операторе объявления локальной переменной, сразу содержавшем в пределах того блока или for оператор. Оператор объявления локальной переменной может содержать выражение, которое инициализирует переменную. Локальная переменная с выражением инициализации не инициализируется, однако, до оператора объявления локальной переменной, который объявляет, что это выполняется. (Правила определенного присвоения (§16) препятствуют тому, чтобы значение локальной переменной использовалось прежде, чем это было инициализировано или иначе присвоило значение.) Локальная переменная эффективно прекращает существование когда выполнение блока или for оператор полон.

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

class Point {
	static int numPoints;								// numPoints is a class variable
	int x, y;								// x and y are instance variables
	int[] w = new int[10];								// w[0] is an array component
	int setX(int x) {								// x is a method parameter
		int oldx = this.x;							// oldx is a local variable
		this.x = x;
		return oldx;
	}
}

4.5.4 Начальные значения Переменных

• Каждая переменная класса, переменная экземпляра, или компонент массива инициализируются со значением по умолчанию, когда это создается (§15.8, §15.9, §20.3.6):
  • Для типа byte, значение по умолчанию является нулем, то есть, значением (byte)0.
  • Для типа short, значение по умолчанию является нулем, то есть, значением (short)0.
  • Для типа int, значение по умолчанию является нулем, то есть, 0.
  • Для типа long, значение по умолчанию является нулем, то есть, 0L.
  • Для типа float, значение по умолчанию является положительным нулем, то есть, 0.0f.
  • Для типа double, значение по умолчанию является положительным нулем, то есть, 0.0d.
  • Для типа char, значение по умолчанию является нулевым символом, то есть,'\u0000'.
  • Для типа boolean, значение по умолчанию false.
  • Для всех ссылочных типов (§4.3), значение по умолчанию null.
• Каждый параметр метода (§8.4.1) инициализируется к соответствующему значению аргумента, обеспеченному invoker метода (§15.11).
• Каждый параметр конструктора (§8.6.1) инициализируется к соответствующему значению аргумента, обеспеченному выражением создания экземпляра класса (§15.8) или явный вызов конструктора (§8.6.5).
• Параметр обработчика исключений (§14.18) инициализируется к брошенному объекту, представляющему исключение (§11.3, §14.16).
• Локальная переменная (§14.3, §14.12) должна быть явно задана значение прежде, чем она будет использоваться, или инициализацией (§14.3) или присвоением (§15.25), в пути, который может быть проверен компилятором, используя правила для определенного присвоения (§16).

class Point {
	static int npoints;
	int x, y;
	Point root;
}


class Test {
	public static void main(String[] args) {
		System.out.println("npoints=" + Point.npoints);
		Point p = new Point();
		System.out.println("p.x=" + p.x + ", p.y=" + p.y);
		System.out.println("p.root=" + p.root);
	}
}

npoints=0
p.x=0, p.y=0
p.root=null

4.5.5 У переменных Есть Типы, у Объектов Есть Классы

(Иногда у переменной или выражения, как говорят, есть "тип времени выполнения", но это - злоупотребление терминологией; это обращается к классу объекта, упомянутого значением переменной или выражения во время выполнения, предполагая, что значение не null. Должным образом разговор, тип является понятием времени компиляции. У переменной или выражения есть тип; объект или массив не имеют никакого типа, но принадлежат классу.)

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

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

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

public interface Colorable {
	void setColor(byte r, byte g, byte b);
}

class Point { int x, y; }

class ColoredPoint extends Point implements Colorable {

	byte r, g, b;


	public void setColor(byte rv, byte gv, byte bv) {
		r = rv; g = gv; b = bv;
	}

}


class Test {
	public static void main(String[] args) {
		Point p = new Point();
		ColoredPoint cp = new ColoredPoint();
		p = cp;
		Colorable c = cp;
	}
}

• Локальная переменная p из метода main из класса Test имеет тип Point и первоначально присваивается ссылка на новый экземпляр класса Point.
• Локальная переменная cp так же имеет как его тип ColoredPoint, и первоначально присваивается ссылка на новый экземпляр класса ColoredPoint.
• Присвоение значения cp к переменной p причины p содержать ссылку на a ColoredPoint объект. Это разрешается потому что ColoredPoint подкласс Point, так класс ColoredPoint присвоение, совместимое (§5.2) с типом Point. A ColoredPoint объект включает поддержку всех методов a Point. В дополнение к его определенным полям r, g, и b, у этого есть поля класса Point, а именно, x и y.
• Локальная переменная c имеет как его тип интерфейсный тип Colorable, таким образом, это может содержать ссылку на любой объект, класс которого реализует Colorable; определенно, это может содержать ссылку на a ColoredPoint.
• Отметьте что выражение такой как"new Colorable()"не допустимо, потому что не возможно создать экземпляр интерфейса, только класса.

new int[10].getClass().getName()

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

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