Spec-Zone .ru
спецификации, руководства, описания, API
|
Содержание | Предыдущий | Следующий | Индекс | Спецификация языка Java Второй Выпуск |
ГЛАВА 4
Язык программирования Java является языком со строгим контролем типов, что означает, что у каждой переменной и каждого выражения есть тип, который известен во время компиляции. Типы ограничивают значения, которые может содержать переменная (§4.5) или что выражение может произвести, ограничить операции, поддерживаемые на тех значениях, и определить значение операций. Строгий контроль типов помогает обнаружить ошибки во время компиляции.
Типы языка программирования Java делятся на две категории: типы примитивов и ссылочные типы. Типы примитивов (§4.2) boolean
введите и числовые типы. Числовые типы являются целочисленными типами byte
, short
, int
, long
, и char
, и типы с плавающей точкой float
и double
. Ссылочные типы (§4.3) являются типами классов, интерфейсными типами, и выстраивают типы. Есть также специальный нулевой тип. Объект (§4.3.1) является динамически создаваемым экземпляром типа класса или динамически создаваемым массивом. Значения ссылочного типа являются ссылками на объекты. Все объекты, включая массивы, поддерживают методы класса Object
(§4.3.2). Строковые литералы представляются String
объекты (§4.3.3).
Имена типов используются (§4.4) в объявлениях, бросках, выражениях создания экземпляра класса, выстраивают выражения создания, литералы класса, и instanceof
выражения оператора.
Переменная (§4.5) является местом хранения. Переменная типа примитива всегда содержит значение того точного типа. Переменная типа класса T может содержать нулевую ссылку или ссылку на экземпляр класса T или любого класса, который является подклассом T. Переменная интерфейсного типа может содержать нулевую ссылку или ссылку на любой экземпляр любого класса, который реализует интерфейс. Если T является типом примитива, то переменная типа "массив T" может содержать нулевую ссылку или ссылку на любой массив типа "массив T"; если T является ссылочным типом, то переменная типа "массив T" может содержать нулевую ссылку или ссылку на любой массив типа "массив S" так, что, тип S присваиваем (§5.2) типу T. Переменная типа Object
может содержать нулевую ссылку или ссылку на любой объект, ли экземпляр класса или массив.
Type:
PrimitiveType
ReferenceType
Есть также специальный нулевой тип, тип выражения null
, у которого нет никакого имени. Поскольку у нулевого типа нет никакого имени, невозможно объявить переменную нулевого типа или бросить к нулевому типу. Нулевая ссылка является единственным возможным значением выражения нулевого типа. Нулевая ссылка может всегда бросаться к любому ссылочному типу. Практически, программист может проигнорировать нулевой тип и только симулировать это null
просто специальный литерал, который может иметь любой ссылочный тип.
PrimitiveType: NumericTypeПримитивные значения не совместно используют состояние с другими примитивными значениями. Переменная, тип которой является типом примитива всегда, содержит примитивное значение того же самого типа. Значение переменной типа примитива может быть изменено только операциями присвоения на той переменной.boolean
NumericType: IntegralType FloatingPointType IntegralType: one ofbyte short int long char
FloatingPointType: one offloat 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.
byte
, от-128 до 127, включительно
short
, от-32768 до 32767, включительно
int
, от-2147483648 до 2147483647, включительно
long
, от-9223372036854775808 до 9223372036854775807, включительно
char
, от '\u0000'
к '\uffff'
включительно, то есть, от 0 до 65535
boolean
: <
, <=
, >
, и >=
(§15.20.1)
==
и !=
(§15.21.1)
int
или long
: +
и -
(§15.15.3, §15.15.4)
*
, /
, и %
(§15.17)
+
и -
(§15.18.2)
++
, и префикс (§15.15.1) и постфикс (§15.14.1)
--
, и префикс (§15.15.2) и постфикс (§15.14.2)
<<
, >>
, и >>>
(§15.19)
~
(§15.15.5)
&
, |
, и ^
(§15.22.1)
? :
(§15.25)
+
(§15.18.1), который, когда дано a String
операнд и интегральный операнд, преобразует интегральный операнд в a String
представление его значения в десятичной форме, и затем производит недавно создаваемый String
это - связь двух строк Byte
, Short
, Integer
, Long
, и Character
.
Если у целочисленного оператора кроме оператора сдвига есть по крайней мере один операнд типа long
, тогда работа выполняется, используя 64-разрядную точность, и результат числового оператора имеет тип long
. Если другой операнд не long
, это сначала расширяется (§5.1.4), чтобы ввести long
числовым продвижением (§5.6). Иначе, работа выполняется, используя 32-разрядную точность, и результат числового оператора имеет тип int
. Если любой операнд не int
, это сначала расширяется до типа int
числовым продвижением.
Встроенные целочисленные операторы не указывают на переполнение или потерю значимости всегда. Единственные числовые операторы, которые могут выдать исключение (§11), являются целочисленным оператором дележа /
(§15.17.2) и целочисленный оператор остатка %
(§15.17.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
ArithmeticException
в подразделении l
-
i
, потому что l
-
i
нуль. Первое умножение выполняется в 32-разрядной точности, тогда как второе умножение является a long
умножение. Значение -727379968
десятичное значение низких 32 битов математического результата, 1000000000000
, который является значением, слишком большим для типа int
.
Любое значение любого целочисленного типа может быть брошено к или от любого числового типа. Нет никаких бросков между целочисленными типами и типом boolean
.
float
и double
, которые концептуально связываются с 32-разрядной одинарной точностью и двойная точность 64-разрядные значения формата IEEE 754 и операции как определено в Стандарте IEEE для Двоичной Арифметики С плавающей точкой, Стандарт ANSI/IEEE 754-1985 (IEEE, Нью-Йорк).
Стандарт IEEE 754 включает не только положительные и отрицательные числа, которые состоят из знака и величины, но также и положительных и отрицательных нулей, положительные и отрицательные бесконечности, и специальные значения Не-числа (после этого сокращал НЭН). Значение НЭН используется, чтобы представить результат определенных недопустимых операций, таких как делящийся нуль нулем. Константы НЭН обоих float
и double
тип предопределяется как Float.NaN
и Double.NaN
.
Каждая реализация языка программирования Java обязана поддерживать два стандартных набора значений с плавающей точкой, названных набором значений плавающим и двойным набором значений. Кроме того, реализация языка программирования Java может поддерживать или или обе из двух расширенных экспонент наборы значений с плавающей точкой, названные набором значений "расширенная экспонента плавающая" и набор значений "двойная расширенная экспонента". Эти наборы значений расширенной экспоненты, при определенных обстоятельствах, могут использоваться вместо стандартных наборов значений, чтобы представить значения выражений типа float
или double
(§5.1.8, §15.4).
Конечные ненулевые значения любого набора значений с плавающей точкой могут все быть выражены в форме, где s +1 или-1, м. является положительным целым числом меньше чем, и e является целым числом между и, включительно, и где N и K являются параметрами, которые зависят от набора значений. Некоторые значения могут быть представлены в этой форме больше чем одним способом; например, если значение v в наборе значений могло бы быть представлено в этой форме, используя определенные значения для s, м., и e, затем если бы это произошло, которым м. был даже, и e были меньше чем, то можно было разделить на два м. и увеличить e на 1, чтобы произвести второе представление для того же самого значения v. Представление в этой форме вызывают нормализованное если; иначе представление, как говорят, денормализовывается. Если значение в наборе значений не может быть представлено таким способом, которым, то значение, как говорят, является денормализованным значением, потому что у этого нет никакого нормализованного представления.
Ограничения на параметры N и K (и на полученные параметры Эмин и Эмэкс) для этих требуемых двух и два дополнительных набора значений с плавающей точкой получаются в итоге в Таблице 4.1.
Где один или оба набора значений расширенной экспоненты поддерживаются реализацией, затем для каждого поддерживаемого набора значений расширенной экспоненты есть определенный зависящий от реализации постоянный K, значение которого ограничивается Таблицей 4.1; это значение K поочередно диктует значения для Эмина и Эмэкса.
Каждый из этих четырех наборов значений включает не только конечные ненулевые значения, которые приписываются ему выше, но также и значения НЭН и четыре значения положительный нуль, отрицательный нуль, положительная бесконечность, и отрицательная бесконечность.
Отметьте, что ограничения в Таблице 4.1 разрабатываются так, чтобы каждый элемент набора значений плавающего был обязательно также элементом набора значений "расширенная экспонента плавающая", двойной набор значений, и набор значений "двойная расширенная экспонента". Аналогично, каждый элемент двойного набора значений является обязательно также элементом набора значений "двойная расширенная экспонента". Каждый набор значений расширенной экспоненты имеет больший диапазон значений экспоненты чем соответствующий стандартный набор значений, но не имеет большей точности.
Элементы набора значений плавающего являются точно значениями, которые могут быть представлены, используя единственный формат с плавающей точкой, определенный в стандарте IEEE 754. Элементы двойного набора значений являются точно значениями, которые могут быть представлены, используя двойной формат с плавающей точкой, определенный в стандарте IEEE 754. Отметьте, однако, что элементы "плавания, расширенная экспонента" и наборы значений "двойная расширенная экспонента", определенная здесь, не соответствуют значениям, которые могут быть представлены, используя IEEE 754 единственные расширенные и двойные расширенные форматы, соответственно.
Плавание, "расширенная экспонента плавающая", дважды, и наборы значений "двойная расширенная экспонента" не является типами. Это всегда корректно для реализации языка программирования Java, чтобы использовать элемент набора значений плавающего, чтобы представить значение типа float
; однако, может быть допустимо в определенных областях кода для реализации использовать элемент набора значений "расширенная экспонента плавающая" вместо этого. Точно так же это всегда корректно для реализации, чтобы использовать элемент двойного набора значений, чтобы представить значение типа double
; однако, может быть допустимо в определенных областях кода для реализации использовать элемент набора значений "двойная расширенная экспонента" вместо этого.
За исключением НЭН, упорядочиваются значения с плавающей точкой; расположенный от самого маленького до самого большого, они - отрицательная бесконечность, отрицательные конечные ненулевые значения, положительный и отрицательный нуль, положительные конечные ненулевые значения, и положительная бесконечность.
IEEE 754 позволяет многократные отличные значения НЭН для каждого из его единственных и двойных форматов с плавающей точкой. В то время как каждая аппаратная архитектура возвращает определенную комбинацию двоичных разрядов для НЭН, когда новая НЭН сгенерирована, программист может также создать NaNs с различными комбинациями двоичных разрядов, чтобы закодировать, например, ретроспективную диагностическую информацию.
По большей части платформа Java обрабатывает значения НЭН данного типа, как если бы свернутый в единственное каноническое значение (и следовательно эта спецификация обычно обращается к произвольной НЭН как если бы к каноническому значению). Однако, версия 1.3 платформа Java представленные методы, позволяющие программисту различать значения НЭН: Float.floatToRawIntBits
и Double.doubleToRawLongBits
методы. Заинтересованный читатель относится в спецификации для Float
и Double
классы для получения дополнительной информации.
Положительный нулевой и отрицательный нуль сравнивается равный; таким образом результат выражения 0.0==-0.0
true
и результат 0.0>-0.0
false
. Но другие операции могут отличить положительный и отрицательный нуль; например, 1.0/0.0
имеет значение положительная бесконечность, в то время как значение 1.0/-0.0
отрицательная бесконечность.
НЭН неупорядочивают, таким образом, числовые операторы сравнения <
, <=
, >
, и >=
возвратиться false
если или или оба операнда НЭН (§15.20.1). Оператор равенства ==
возвраты false
если любым операндом является НЭН, и оператор неравенства !=
возвраты true
если любым операндом является НЭН (§15.21.1). В частности x!=x
true
если и только если x
НЭН, и (x<y)
==
!(x>=y)
будет false
если x
или y
НЭН.
Любое значение типа с плавающей точкой может быть брошено к или от любого числового типа. Нет никаких бросков между типами с плавающей точкой и типом boolean
.
boolean
: <
, <=
, >
, и >=
(§15.20.1)
==
и !=
(§15.21.1)
float
или double
: +
и -
(§15.15.3, §15.15.4)
*
, /
, и %
(§15.17)
+
и -
(§15.18.2)
++
, и префикс (§15.15.1) и постфикс (§15.14.1)
--
, и префикс (§15.15.2) и постфикс (§15.14.2)
? :
(§15.25)
+
(§15.18.1), который, когда дано a String
операнд и операнд с плавающей точкой, преобразует операнд с плавающей точкой в a String
представление его значения в десятичной форме (без информационной потери), и затем производит недавно создаваемый String
связывая две строки Float
, Double
, и Math
.Если по крайней мере один из операндов к бинарному оператору имеет тип с плавающей точкой, то работа является работой с плавающей точкой, даже если другой является неотъемлемой частью.
Если по крайней мере один из операндов числовому оператору имеет тип double
, тогда работа выполняется, используя 64-разрядную арифметику с плавающей точкой, и результатом числового оператора является значение типа double
. (Если другой операнд не является a double
, это сначала расширяется до типа double
числовым продвижением (§5.6).) Иначе, работа выполняется, используя 32-разрядную арифметику с плавающей точкой, и результатом числового оператора является значение типа float.
Если другой операнд не является a float
, это сначала расширяется до типа float
числовым продвижением.
Операторы на числах с плавающей точкой ведут себя как определено IEEE 754 (за исключением оператора остатка (§15.17.3)). В частности язык программирования Java требует поддержки IEEE 754 денормализованные числа с плавающей точкой и постепенная потеря значимости, которые облегчают доказывать требуемые свойства определенных числовых алгоритмов. Операции с плавающей точкой "не сбрасывают, чтобы обнулить", если расчетным результатом является денормализованное число.
Язык программирования Java требует, чтобы арифметика с плавающей точкой вела себя как будто каждый оператор с плавающей точкой, округленный ее результат с плавающей точкой к точности результата. Неточные результаты должны быть округлены к представимому значению, самому близкому к бесконечно точному результату; если два самых близких представимых значения одинаково рядом, тот с его младшим значащим разрядным нулем выбирается. Это - значение по умолчанию стандарта IEEE 754 округление режима, известного как вокруг самому близкому.
Язык использует вокруг к нулю, преобразовывая плавающее значение в целое число (§5.1.3), который действует, в этом случае, как если бы число было усеченным, отбрасывая биты мантиссы. Округление к нулю выбирает в его результате значение формата, самое близкое к и не больше в величине чем бесконечно точный результат.
Операторы с плавающей точкой не производят исключений (§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
.
boolean
Введите и boolean
Значенияboolean
тип представляет логическое количество с двумя возможными значениями, обозначенными литералами true
и false
(§3.10.3). Булевы операторы:
==
и !=
(§15.21.2)
!
(§15.15.6)
&
, ^
, и |
(§15.22.2)
&&
(§15.23) и ||
(§15.24)
? :
(§15.25)
+
(§15.18.1), который, когда дано a String
операнд и булев операнд, преобразует булев операнд в a String
(также "true"
или "false"
), и затем произведите недавно создаваемый String
это - связь двух строк A
boolean
выражение также определяет, какое подвыражение оценивается в условном выражении ? :
оператор (§15.25).
Только 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).
ReferenceType:
ClassOrInterfaceType
ArrayType
ClassOrInterfaceType:
ClassType
InterfaceType
ClassType:
TypeName
InterfaceType:
TypeName
ArrayType:
Type [ ]
Имена описываются в §6; имена типов в §6.5 и, определенно, §6.5.5.объявляет тип классаclass Point { int[] metrics; } interface Move { void move(int deltax, int deltay); }
Point
, интерфейсный тип Move
, и использует тип массива int[]
(массив int
) объявить поле metrics
из класса Point
.Ссылочные значения (часто только ссылки) являются указателями на эти объекты, и специальной нулевой ссылкой, которая не обращается ни к какому объекту.
Экземпляр класса явно создается выражением создания экземпляра класса (§15.9). Массив явно создается выражением создания массива (§15.9).
Новый экземпляр класса неявно создается, когда оператор конкатенации строк + (§15.18.1) используется в выражении, приводящем к новому объекту типа String
(§4.3.3). Новый объект массива неявно создается, когда выражение инициализатора массива (§10.6) оценивается; это может произойти, когда класс или интерфейс инициализируются (§12.4), когда новый экземпляр класса создается (§15.9), или когда оператор объявления локальной переменной выполняется (§14.4).
Многие из этих случаев иллюстрируются в следующем примере:
который производит вывод: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
+
(§15.18.1), который, когда дано a String
операнд и ссылка, преобразует ссылку на a String
вызывая toString
метод объекта, на который ссылаются (использование "null"
если или ссылка или результат toString
нулевая ссылка), и затем произведет недавно создаваемый String
это - связь двух строк
instanceof
оператор (§15.20.2)
==
и !=
(§15.21.3)
? :
(§15.25). производит вывод: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
v1.val
и v2.val
сошлитесь на ту же самую переменную экземпляра (§4.5.3) в том Value
объект создается единственным new
выражение, в то время как i1
и i2
различные переменные.
См. §10 и §15.10 для примеров создания и использования массивов. У каждого объекта есть связанная блокировка (§17.13), который используется synchronized
методы (§8.4.3) и synchronized
оператор (§14.18), чтобы обеспечить управление параллельным доступом, чтобы утвердить многократными потоками (§17.12).
Object
суперкласс (§8.1) всех других классов. Переменная типа Object
может содержать ссылку на любой объект, является ли это экземпляром класса или массива (§10). Весь класс и типы массива наследовали методы класса 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 { . . . } }
Object
следующие:
getClass
возвраты Class
объект, который представляет класс объекта. A Class
объект существует для каждого ссылочного типа. Это может использоваться, например, чтобы обнаружить полностью определенное имя класса, его элементов, его непосредственного суперкласса, и любых интерфейсов, которые это реализует. Метод класса, который объявляется synchronized
(§8.4.3.6) синхронизируется на блокировке, связанной с Class
объект класса.
toString
возвраты a String
представление объекта.
equals
и hashCode
очень полезны в хеш-таблицах такой как java.util.Hashtable
. Метод equals
определяет понятие объектного равенства, которое основано на значении, не ссылке, сравнении.
clone
используется, чтобы сделать копию объекта.
wait
, notify
, и notifyAll
используются в параллельном программировании, используя потоки, как описано в §17.
finalize
выполняется непосредственно перед тем, как объект уничтожается и описывается в §12.6. String
представьте последовательности символов Unicode. A String
у объекта есть постоянное (неизменное) значение. Строковые литералы (§3.10.5) являются ссылками на экземпляры класса String
.
Оператор конкатенации строк +
(§15.18.1) неявно создает новое String
объект.
Во время выполнения несколько ссылочных типов с тем же самым двоичным именем могут быть загружены одновременно различными загрузчиками класса. Эти типы могут или, возможно, не представляют то же самое описание типа. Даже если два таких типа действительно представляют то же самое описание типа, их считают отличными.
Два ссылочных типа являются тем же самым типом времени выполнения если:
Следующий фрагмент кода содержит один или более экземпляров большинства видов использования типа:
В этом примере типы используются в объявлениях следующего: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; } }
Random
, импортированный из типа java.util.Random
из пакета java.util
, объявляется
divisor
в классе MiscMath
как объявляют, имеет тип int
l
из метода ratio
как объявляют, имеет тип long
ratio
как объявляют, имеет тип float
, и результат метода gausser
как объявляют, имеет тип double
MiscMath
как объявляют, имеет тип int
r
и val
из метода gausser
как объявляют, имеют типы Random
и double[]
(массив double
)
e
из catch
пункт, как объявляют, имеет тип Exception
r
из метода gausser
инициализируется выражением создания экземпляра класса, которое использует тип Random
val
из метода gausser
инициализируется выражением создания массива, которое создает массив double
с размером 2
return
оператор метода ratio
использование float
введите бросок
instanceof
оператор (§15.20.2); здесь instanceof
оператор тестирует ли e
присвоение, совместимое с типом ArithmeticException
++
(инкремент) или --
(декрементный) оператор (§15.14.1, §15.14.2, §15.15.1, §15.15.2).Совместимость значения переменной с ее типом гарантируется проектом языка программирования Java. Значения по умолчанию являются совместимыми (§4.5.5), и все присвоения на переменную проверяются на совместимость присвоения (§5.2), обычно во время компиляции, но, в единственных массивах включения случая, проверка на этапе выполнения делается (§10.10).
static
в пределах объявления класса (§8.3.1.1), или с или без ключевого слова static
в пределах интерфейсного объявления (§9.3). Переменная класса создается, когда ее класс или интерфейс готовятся (§12.3.2) и инициализируются к значению по умолчанию (§4.5.5). Переменная класса эффективно прекращает существование, когда ее класс или интерфейс разгружаются (§12.7).
static
(§8.3.1.1). Если у класса T есть поле a, которое является переменной экземпляра, то новая переменная экземпляра создаваемого и инициализированного к значению по умолчанию (§4.5.5) как часть каждого недавно создаваемого объекта класса T или любого класса, который является подклассом T (§8.1.3). Переменная экземпляра эффективно прекращает существование, когда, объектом которого это - поле, больше не ссылается, после любого необходимого завершения объекта был завершен (§12.6).
catch
пункт a try
оператор (§14.19). Новая переменная инициализируется с фактическим объектом, связанным с исключением (§11.3, §14.17). Параметр обработчика исключений эффективно прекращает существование когда выполнение блока, связанного с catch
пункт полон.
for
оператор (§14.13), новая переменная создается для каждой локальной переменной, объявленной в операторе объявления локальной переменной, сразу содержавшем в пределах того блока или for
оператор. Оператор объявления локальной переменной может содержать выражение, которое инициализирует переменную. Локальная переменная с выражением инициализации не инициализируется, однако, до оператора объявления локальной переменной, который объявляет, что это выполняется. (Правила определенного присвоения (§16) препятствуют тому, чтобы значение локальной переменной использовалось прежде, чем это было инициализировано или иначе присвоило значение.) Локальная переменная эффективно прекращает существование когда выполнение блока или for
оператор полон. switch
оператор (§14.10), где для управления возможно ввести блок, но обходное выполнение оператора объявления локальной переменной. Из-за ограничений, введенных правилами определенного присвоения (§16), однако, не может использоваться локальная переменная, объявленная таким обошедшим оператором объявления локальной переменной прежде, чем это было определенно присвоено значение выражением присвоения (§15.26). Следующий пример содержит несколько различных видов переменных: 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; } }
final
. Заключительная переменная может только быть присвоена однажды. Это - ошибка времени компиляции, если заключительная переменная присваивается тому, если это не является определенно неприсвоенным (§16) сразу до присвоения.Пустой финал является заключительной переменной, объявление которой испытывает недостаток в инициализаторе.
Однажды a final
переменная была присвоена, она всегда содержит то же самое значение. Если a final
переменная содержит ссылку на объект, тогда состояние объекта может быть изменено операциями на объекте, но переменная будет всегда обращаться к тому же самому объекту. Это применяется также массивам, потому что массивы являются объектами; если a final
переменная содержит ссылку на массив, тогда компоненты массива могут быть изменены операциями на массиве, но переменная будет всегда обращаться к тому же самому массиву.
Объявление переменной final
может служить полезной документацией, которую ее значение не будет изменять и может помочь избежать программировать ошибки.
В примере:
классclass Point { int x, y; int useCount; Point(int x, int y) { this.x = x; this.y = y; } final static Point origin = new Point(0, 0); }
Point
объявляет a final
переменная класса origin
. origin
переменная содержит ссылку на объект, который является экземпляром класса Point
чьи координаты (0, 0). Значение переменной Point.origin
никогда не может изменяться, таким образом, это всегда обращается к тому же самому Point
объект, тот создается его инициализатором. Однако, работа на этом Point
объект мог бы изменить свое состояние например, изменяя его useCount
или даже, обманчиво, x
или y
координата.
byte
, значение по умолчанию является нулем, то есть, значением (byte)0
.
short
, значение по умолчанию является нулем, то есть, значением (short)0
.
int
, значение по умолчанию является нулем, то есть, 0
.
long
, значение по умолчанию является нулем, то есть, 0L
.
float
, значение по умолчанию является положительным нулем, то есть, 0.0f
.
double
, значение по умолчанию является положительным нулем, то есть, 0.0d
.
char
, значение по умолчанию является нулевым символом, то есть, '\u0000'
.
boolean
, значение по умолчанию false
.
null
.
печатные издания: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
npoints
, который происходит когда класс Point
готовится (§12.3.2), и инициализация по умолчанию x
, y
, и root
, который происходит когда новое Point
инстанцируется. См. §12 для полного описания всех аспектов загрузки, соединения, и инициализации классов и интерфейсов, плюс описание инстанцирования классов, чтобы сделать новые экземпляры класса.
Каждый объект принадлежит некоторому определенному классу: класс, который был упомянут в выражении создания, которое произвело объект, класс чей Class
объект использовался, чтобы вызвать отражающий метод, чтобы произвести объект, или String
класс для объектов неявно создается оператором конкатенации строк +
(§15.18.1). Этот класс вызывают классом объекта. (У массивов также есть класс, как описано в конце этого раздела.) Объект, как говорят, является экземпляром своего класса и всех суперклассов его класса.
Иногда у переменной или выражения, как говорят, есть "тип времени выполнения". Это обращается к классу объекта, упомянутого значением переменной или выражения во время выполнения, предполагая, что значение не 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()
"не допустимо, потому что не возможно создать экземпляр интерфейса, только класса. getClass
, когда вызвано для объекта массива, возвратит объект класса (класса Class
) это представляет класс массива.
У классов для массивов есть странные имена, которые не являются допустимыми идентификаторами; например, класс для массива int
у компонентов есть имя"[I
"и так значение выражения:
строкаnew int[10].getClass().getName()
"[I"
; см. спецификацию Class.getName
для деталей.
Содержание | Предыдущий | Следующий | Индекс | Спецификация языка Java Второй Выпуск |