Перейти на главную   
  helloworld.ru - документация и книги по программированию  
helloworld.ru - документация и книги по программированию
    главная     хостинг    
Поиск по сайту:  
Смотрите также
Языки программирования
C#
MS Visual C++
Borland C++
C++ Builder
Visual Basic
Quick Basic
Turbo Pascal
Delphi
JavaScript
Java
PHP
Perl
Assembler
AutoLisp
Fortran
Python
1C

Интернет-технологии
HTML
VRML
HTTP
CGI
FTP
Proxy
DNS
протоколы TCP/IP
Apache

Web-дизайн
HTML
Дизайн
VRML
PhotoShop
Cookie
CGI
SSI
CSS
ASP
PHP
Perl

Программирование игр
DirectDraw
DirectSound
Direct3D
OpenGL
3D-графика
Графика под DOS

Алгоритмы
Численные методы
Обработка данных

Сис. программирование
Драйверы

Базы данных
MySQL
SQL

Другое

Хостинг


Друзья
demaker.ru
Реклама

Лучший хостинг. Аренда серверов



Bych01.ru

helloworld.ru

ГЛАВА 3. Лексическая структура

Эта глава определяет лексическую структуру языка Ява.

Программы на языке Ява записываются символами Unicode (§ 3.1), поэтому необходимы лексические преобразования (§ 3.2) для того, чтобы Unicode-последовательности (§ 3.3), состоящие только из символов ASCII, могли быть использованы для записи любого Unicodе-символа. Ограничители строки определены (§ 3.4) для того, чтобы поддерживать различные соглашения существующих систем по нумерации строк.

Unicode-cимволы, являющиеся результатами лексических преобразований, переводятся в последовательность элементов ввода (§ 3.5), которыми являются незначащие символы (§ 3.6), комментарии (§ 3.7), и лексемы. К лексемам относятся: идентификаторы (§ 3.8), ключевые слова (§ 3.9), литералы (§ 3.10), разделители (§ 3.11) и знаки операций (§ 3.12) синтаксической грамматики языка Ява.

3.1 Unicode

Программы на языке Ява записываются с помощью набора Unicode-символов, версии 2.0. Информация относительно кодирования может быть найдена в:

http://www.unicode.org 
and ftp://unicode.org

Версии языка Ява до 1.1 использовали версию Unicode 1.1.5 (см. The Unicodestandard: Worldwide Character Encoding (§1.2) and updates). См. § 20.5 для выяснения различий между версиями Unicode 1.1.5 и Unicode 2.0.

Исключая комментарии (§ 3.7), идентификаторы, содержимое символьных и строковых литералов (§ 3.10.4, § 3.10.5), все элементы ввода (§ 3.5) в программе на языке Ява образуются только из символов ASCII (или Unicode-последовательностей (§ 3.3), которые дают символы ASCII). ASCII (ANSI X3. 4) - это американский стандартный код для обмена информацией (the American Standard Code for Information Interchange). Первые 128 Unicode-символов - символы ASCII.

3.2 Лексическая трансляция

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

  1. Трансляция Unicode-последовательностей (§ 3.3) в соответствующие Unicode-символы. Unicode-последовательность формы \ uxxxx, где xxxx - шестнадцатиричное число , представляет Unicode-символ, чьим кодом является - xxxx. Этот шаг позволяет представить любую программу на языке Ява, используя только ASCII-символы.
  2. Трансляция Unicode-последовательности, являющейся результатом шага 1, в последовательность входных символов и ограничителей строк (§ 3.4).
  3. Трансляция последовательности входных символов и ограничителей строк, являющейся результатом шага 2, в последовательность элементов ввода языка Ява (§ 3.5), которая после исключения незначащих символов (§ 3.6) и комментариев (§ 3.7) состоит из лексем (§ 3.5), которые являются терминальными символами синтаксической грамматики (§ 2.3) языка Ява.

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

3.3 Unicode-последовательности

Транслятор языка Ява сначала распознает Unicode-последовательности при вводе, переводя ASCII-символы \u с последующими за ними четырьмя шестнадцатиричными цифрами в Unicode-символ с соответствующим шестнадцатиричным значением, и оставляя все другие символы неизменными. Результатом этого шага является последовательность входных Unicode-символов:

 

    UnicodeInputCharacter:
    UnicodeEscape
    RawInputCharacter
    UnicodeEscape:
    	\ 
    UnicodeMarker
    HexDigit
    HexDigit
    HexDigit
    HexDigit
    UnicodeMarker:
    u
    UnicodeMarker
     u 
    RawInputCharacter:
    любой Unicode символ
    HexDigit:
    one 
    of	
    0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F
    

\, u, и шестнадцатиричные цифры являются ASCII-символами.

В дополнение к обработке, подразумеваемой грамматикой, для каждого входного символа, который является обратной наклонной чертой \, нужно учитывать, сколько других расположенных рядом символов \ , предшествуют данному, отделяя его от символа, не являющегося символом наклонной черты ( \ ), или начала входной последовательности. Если число символов \ четно, то \ может начинать Unicode-последовательность; если нечетно, не может. Например, обработка последовательности "\\u2297=\u2297" даст результаты из одиннадцати знаков "\\u2297=[Image]" ( \u2297 - Unicode-код для символа “[Image]”).

Если допустимая наклонная черта ( \ ) не сопровождается u, то она рассматривается как RawInputCharacter и остается частью выходной Unicode-последовательности. Если допустимая наклонная черта ( \ ) сопровождается u, или более чем одним символом u, и последний символ u не сопровождается четырьмя шестнадцатиричными цифрами, тогда происходит ошибка времени компиляции.

Символ, полученный из Unicode-последовательности не попадает в новую Unicode-последовательность. Например, входная последовательность \u005cu005a дает результат, состоящий из шести знаков \u005a, потому что 005c - Unicode-значение для \.Она не дает результат в виде символа Z, который является символом с кодом 005a, потому что \, который получился из \u005c не интерпретируется как начало новой Unicode-последовательности.

В Яве определен стандартный путь преобразования Unicode-программы на Яве в ASCII, который позволяет представить программу, написанную на языке Ява, в форме, которая может быть обработана инструментами, базирующимися на ASCII. Преобразование предусматривает замену любой Unicode-последовательности исходного текста программы на ASCII-последовательность, приписывая дополнительный символ u, например, последовательность \uxxxx преобразуется в последовательность \uuxxxx, в то время как символы, которые не могут быть представлены в коде ASCII, преобразуются к \uxxxx-последовательностям, содержащим единственный u. Такая преобразованная версия одинаково приемлема для компилятора языка Ява и представляет ту же самую программу. Точный исходный Unicode-текст может быть позже восстановлен по этой ASCII-форме, с помощью конвертирования каждой последовательности, где u содержится многократно, к последовательности Unicode-символов с количеством u, меньшим на 1, преобразовании каждой последовательности с единственным u к соответствующему единственному Unicode-символу.

Когда подходящий шрифт недоступен, Ява-системы должны использовать для отображения при выводе Unicode-символов формат \uxxxx.

3.4 Ограничители строк

Компилятор языка Ява делит последовательность входных Unicode-символов на строки, распознавая ограничители строк. Это разделение определяет номера строк, формируемые компилятором языка Ява или другими компонентами Ява-системы. Оно также определяет границы // комментария (§ 3.7).

 

    LineTerminator:
    
    	ASCII символ LF, также называемый "новая строка"
    
    	ASCII символ CR, также называемый "return"
    
    	ASCII символ CR следующий за ASCII символом LF
    
    InputCharacter:
    
    	UnicodeInputCharacter but not CR or LF
    

Строки программы заканчиваются ASCII-символами CR, или LF, или CR LF. Два подряд идущих символа CR и LF являются одним ограничителем строки, а не двумя. Результат - последовательность разделителей строк и входных символов, которые являются терминальными символами третьего шага лексического анализа.

3.5 Элементы ввода и лексемы

Входные символы и ограничители строк, которые получились после обработки Unicode-последовательностей (§ 3.3) и последующего распознавания строк (§ 3.4), преобразуются в последовательности элементов ввода. Элементы ввода, которые не являются незначащими символами (§ 3.6) или комментариями (§ 3.7) являются лексемами. Лексемы - это терминальные символы синтаксической грамматики языка Ява (§ 2.3).

Этот процесс определен следующими продукциями:

    Input:
    
    	InputElementsopt Subopt
    
    InputElements:
    
    	InputElement
    
    	InputElements InputElement
    
    InputElement:
    
    	WhiteSpace
    
    	Comment
    
    	Token
    
    Token:
    
    	Identifier
    
    	Keyword
    
    	Literal
    
    	Separator
    
    	Operator
    
    Sub:
    
    	the ASCII SUB символ, также называемый "control-Z"
    

Незначащие символы (§ 3.6) и комментарии (§ 3.7) служат для того, чтобы разделять лексемы, которые при слитном написании могли бы интерпретироваться иначе. Например, ASCII-символы - и = могут формировать знак операции –= (§ 3.12) только в случае, если между ними нет никакого незначащего символа или комментария.

Как специальная уступка для совместимости с некоторыми операционными системами, ASCII SUB-символ (\u001а или control-Z) игнорируется, если это последний символ входной последовательности.

Рассмотрим два символа x и y , стоящие во входной последовательности. Если x предшествует y, то мы говорим, что x стоит слева от y, а y - справа от x. Например, как в этой простом фрагменте кода на языке Ява:

class Empty {
}

мы говорим, что лексема } стоит справа от лексемы {, даже если она появляется ниже и левее лексемы { , как в вышеприведенном примере. Это соглашение относительно использования слов левый и правый позволяет нам говорить, например, о правом операнде двуместной операции или левой части оператора присваивания.

3.6 Незначащие символы

Незначащие символы определяются как ASCII - символы: пробел, горизонтальная табуляция, символ перевода страницы, а также ограничители строки (§3.4).

    WhiteSpace:
    
    	ASCII символ SP, также называемый "пробел"
    
    	ASCII символ HT, также называемый "горизонтальная табуляция"
    
    	ASCII символ FF, также называемый "перевод страницы"
    
    	LineTerminator
    

3.7 Комментарии

В языке Ява выделяют три вида комментариев:

/* текст */ - традиционный комментарий: весь текст от ASCII -символов /* до ASCII -символов */ игнорируется (так же как в C и C ++).

// текст - однострочный комментарий: весь текст от ASCII -символов // до конца строки игнорируется (как в C ++).

/** документация */ - комментарий документации: текст, заключенный в ASCII-символы /** и */ может быть обработан отдельной программой, автоматически формирующей документацию объявления данного класса, интерфейса, конструктора, или члена (метод или поле). См. §18 для подробного описания того, как обрабатывается документация.

Данные комментарии формально определяются следующим образом:

 

    Comment:
    
    	TraditionalComment
    
    	EndOfLineComment
    
    	DocumentationComment
    
    TraditionalComment:
    
    	/ * NotStar CommentTail
    
    EndOfLineComment:
    
    	/ / CharactersInLineopt LineTerminator
    
    DocumentationComment:
    
    	/ * * CommentTailStar
    
    CommentTail:
    
    	* CommentTailStar
    
    	NotStar CommentTail
    
    CommentTailStar:
    
    	/
    
    	* CommentTailStar
    
    	NotStarNotSlash CommentTail
    
    NotStar:
    
    	InputCharacter but not *
    
    	LineTerminator
    
    NotStarNotSlash:
    
    	InputCharacter but not * or /
    
    	LineTerminator
    
    CharactersInLine:
    
    	InputCharacter
    
    	CharactersInLine InputCharacter
    

Из этих правил неявно следуют следующие свойства:

 

  • Комментарии не могут быть вложенными.
  • /* и */ не имеют никакого специального значения в комментариях, которые начинаются с //.
  • // - не имеет никакого специального значения в комментариях, которые начинаются с /* или /**.

 

В результате, текст:

 

/* Этот комментарий /* // /** заканчивается здесь: */

- это простой полный комментарий.

Лексическая грамматика предполагает, что комментарии не действуют в пределах символьных (§3.10.4) или строковых литералов (§3.10.5).

Отметим, что /**/ рассматривается как комментарий документации, в то время как /* */ (с пробелом между звездочками) - традиционный комментарий.

3.8 Идентификаторы

Идентификатор - это последовательность неограниченной длины букв и цифр языка Ява, на первом месте в этой последовательности должна быть буква. Идентификатор не может иметь то же самое написание (последовательность Unicode-символов) как и ключевое слово (§3.9), логический литерал (§3.10.3) или null-литерал (§3.10.7).

    Identifier:
    
    	IdentifierChars but not a Keyword or BooleanLiteral or NullLiteral
    
    IdentifierChars:
    
    	JavaLetter
    
    	IdentifierChars JavaLetterOrDigit
    
    JavaLetter:
    
    	любой Unicode символ, который является Ява-буквой (см. ниже)
    
    JavaLetterOrDigit:
    
    	любой Unicode символ, который является Ява-буквой или цифрой (см. ниже)
    

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

Буква в языке Ява - это символ, для которого метод Character.isJavaLetter возвращает значение true (§20.5.17). Буква или цифра Явы - это символ, для которого метод Character.isJavaLetterOrDigit возвращает значение true (§20.5.18).

Буквы языка Ява включают верхний регистр и нижний регистр ASCII -латинских букв: A-Z (\u0041-\u005a), и a-z (\u0061-\u007a), и, по историческим причинам, ASCII -символ подчеркивания (_, или \u005f) и знак доллара ($ или \u0024). Символ "$" должен использоваться только в механически сгенерированном Ява-коде или, изредка, для доступа к уже существующим именам в унаследованных системах.

Цифры языка включают ASCII -цифры 0-9(\u0030-\u0039).

Два идентификатора одинаковы, если они идентичны, то есть имеют одинаковый Unicode-символ для каждой буквы или цифры.

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

Например, идентификаторы, состоящие из отдельных букв: ЛАТИНСКАЯ ЗАГЛАВНАЯ БУКВА A (A, \u0041), ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА A (a, \u0061), ГРЕЧЕСКАЯ ЗАГЛАВНАЯ БУКВА АЛЬФА (A, \u0391), и МАЛЕНЬКАЯ БУКВА КИРИЛЛИЦЫ A (a, \u0430)- все различны.

Сложные Unicode-символы отличаются от простых символов.

Например, ЛАТИНСКАЯ ЗАГЛАВНАЯ БУКВА A ACUTE (A , \u00c1) могла бы рассматриваться также как ЛАТИНСКАЯ ЗАГЛАВНАЯ БУКВА A (A, \u0041), сопровождаемая NON-SPACING ACUTE (r, \u0301) при сортировке, но они различны как идентификаторы языка Ява. См. The Unicode Standart, Volume1, страницы 412ff - подробнее о декомпозиции, и см. страницы 626-627 этой же работы- подробнее о сортировке.

Примеры идентификаторов:

 

String i3  MAX_VALUE  isLetterOrDigit

3.9 Ключевые слова

Следующие последовательности символов, сформированные из ASCII -букв, являются ключевыми словами и не могут использоваться как идентификаторы (§3.8):

 

    Keyword: one of
    
    	abstract	default	if	private	throw
    
    	boolean	do	implements	protected	throws
    
    	break	double	import	public	transient
    
    	byte	else	instanceof	return	try
    
    	case	extends	int	short	void
    
    	catch	final	interface	static	volatile
    
    	char	finally	long	super	while
    
    	class	float	native	switch
    
    	const	for	new	synchronized
    
    	continue	goto	package	this
    

Ключевые слова const и goto зарезервированы языком Ява, даже если в настоящее время они не используются в Яве. Это позволяет компилятору Ява лучше представлять сообщения об ошибке, если эти ключевые слова языка C ++ неправильно применяются в Ява- программах.

Несмотря на то, что слова true и false могли бы использоваться как ключевые слова, их относят к логическим литералам (§3.10.3). Подобно этому, несмотря на то, что слово null могло использоваться как ключевое, оно является null-литералом (§3.10.7).

3.10 Литералы

Литерал - представление в исходном коде значения простого типа (§4.2), типа String (§4.3.3, §20.12) или типа null (§4.1):

    Literal:
    
    	IntegerLiteral
    
    	FloatingPointLiteral
    
    	BooleanLiteral
    
    	CharacterLiteral
    
    	StringLiteral
    
    	NullLiteral
    

3.10.1 Целые литералы

См. §4.2.1 для общего рассмотрения целых типов и значений.

Целый литерал может быть выражен десятичным (основание 10), шестнадцатеричным (основание 16) или восьмеричным (основание 8) числом:

    IntegerLiteral:
    
    	DecimalIntegerLiteral
    
    	HexIntegerLiteral	
    
    	OctalIntegerLiteral
    
    DecimalIntegerLiteral:
    
    	DecimalNumeral IntegerTypeSuffixopt
    
    HexIntegerLiteral:
    
    	HexNumeral IntegerTypeSuffixopt
    
    OctalIntegerLiteral:	
    
    	OctalNumeral IntegerTypeSuffixopt
    
    IntegerTypeSuffix: one of
    
    	l L
    

Целый литерал имеет тип long, если он заканчивается ASCII- буквой L или l(эль); иначе, это литерал типа int (§4.2.1). Суффикс L предпочтителен, потому что букву l (эль) часто трудно отличить от цифры 1 (один).

Десятичная запись числа является либо простым ASCII -символом 0, представляющим ноль, либо состоит из ASCII - цифры от 1 до 9, за которой могут следовать одна или больше ASCII -цифр от 0 до 9, представляющих положительное целое число:

    DecimalNumeral:
    
    	0
    
    	NonZeroDigit Digitsopt
    
    Digits:
    
    	Digit
    
    	Digits Digit
    
    Digit:
    
    	0
    
    	NonZeroDigit
    
    NonZeroDigit: one of
    
    	1 2 3 4 5 6 7 8 9
    

Шестнадцатиричная запись числа состоит из ведущих ASCII -символов 0x или 0X, идущих перед одной либо несколькими ASCII - шестнадцатиричными цифрами и может представлять положительное целое число, ноль или отрицательное целое число. Шестнадцатиричные цифры со значениями от 10 до 15 представляются ASCII - буквами либо f, либо от A до F в указанном порядке, каждая буква, использующаяся как шестнадцатиричная цифра, может быть из верхнего или нижнего регистра.

    HexNumeral:
    
    	0 x HexDigit
    
    	0 X HexDigit
    
    	HexNumeral HexDigit
    

Следующая информация из §3.3 повторяется здесь для ясности:

    HexDigit: one of
    
    	0 1 2 3 4 5 6 7 8 9 a b c d e f A B C D E F
    

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

    OctalNumeral:
    
    	0 OctalDigit
    
    	OctalNumeral OctalDigit
    
    OctalDigit: one of
    
    	0 1 2 3 4 5 6 7
    
     

Заметим, что восьмеричные числа всегда состоят из двух или более цифр; 0 всегда рассматривается как десятичное число - что не имеет большого значения на практике. Числа 0, 00, и 0x0 представляют одно и то же целое значение.

Самый большой десятичный литерал типа int - 2147483648(). Все десятичные литералы от 0 до 2147483647 могут применяться везде, где может применяться литерал типа int, но литерал 2147483648 может использоваться только как операнд одноместной операции отрицания -.

Самые большие положительные шестнадцатиричный и восьмеричный литералы типа int - 0x7fffffff и 017777777777, соответственно, которые равны 2147483647 (). Наибольшие отрицательные шестнадцатиричные и восьмеричные литералы типа int 0x80000000 и 020000000000, соответственно, каждый из которых представляет десятичное значение -2147483648 (). Шестнадцатиричный и восьмеричный литералы 0xffffffff и 037777777777, соответственно, представляют десятичное значение -1.

См. также Integer.MIN_VALUE (§20.7.1) и Integer.MAX_VALUE (§20.7.2).

Ошибка времени компиляции происходит, если десятичный литерал типа int больше числа 2147483648 () или, если литерал 2147483648 применяется не как операнд одноместной операции, или, если шестнадцатиричный или восьмеричный литерал типа int превышает 32 бита.

Примеры литералов типа int:

  0  2  0372  0xDadaCafe  1996  0x00FF00FF

Самый большой десятичный литерал типа long - 9223372036854775808L ().

Все десятичные литералы от 0L до 9223372036854775807L могут использоваться везде, где используется литерал типа long, но литерал 9223372036854775808L может использоваться только как операнд одноместной операции отрицания -.

Самые большие положительные шестнадцатиричные и восьмеричные литералы типа long - 0x7fffffffffffffffL и 0777777777777777777777L, соответственно, которые равны 9223372036854775807L(). Литералы 0x8000000000000000L и 01000000000000000000000L - самые длинные отрицательные шестнадцатиричный и восьмиричный литералы, соответственно. Каждый имеет десятичное значение -9223372036854775808L (). Шестнадцатиричный и восьмиричный литералы 0xffffffffffffffffL и 01777777777777777777777L, соответственно, представляют десятичное значение -1L.

См. также Long.MIN_VALUE (§20.8.1) и Long.MAX_VALUE (§20.8.2).

Ошибка времени компиляции происходит в том случае, если десятичный литерал типа long больше числа 9223372036854775808L() или, если литерал 9223372036854775808 применяется не как операнд одноместной операции, или, если шестнадцатиричный или восьмиричный литерал типа long превышает 64 бита.

Примеры литералов типа long:

0l  0777L  0x100000000L  2147483648L  0xC0B0L

3.10.2 Вещественные литералы

См. §4.2.3 для более общего рассмотрения типов и значений с плавающей точкой.

Вещественный литерал имеет следующие части: целая часть, десятичная точка (представлена ASCII- символом “точка” ), дробная часть, экспонента, и суффикс типа. Экспонента обозначается ASCII- буквой e или E, сопровождаемой целым числом (возможно со знаком).

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

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

Вещественный литерал имеет тип float, если он заканчивается ASCII -буквой F или f; иначе он имеет тип double, и может заканчиваться ASCII -буквой D или d.

    FloatingPointLiteral:
    
    	Digits . Digitsopt ExponentPartopt FloatTypeSuffixopt
    
    	. Digits ExponentPartopt FloatTypeSuffixopt
    
    	Digits ExponentPart FloatTypeSuffixopt
    
    	Digits ExponentPartopt FloatTypeSuffix
    
    ExponentPart:
    
    	ExponentIndicator SignedInteger
    
    ExponentIndicator: one of
    
    	e E
    
    SignedInteger:
    
    	Signopt Digits
    
    Sign: one of
    
    	+ -
    
    FloatTypeSuffix: one of
    
    	f F d D
    

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

Подробности входного преобразования от Unicode строкового представления числа с плавающей точкой к внутреннему IEEE 754 двоичному представлению с плавающей точкой описаны для методов valueOf класса Float (§20.9.17) и класса Double (§20.10.16) пакета java.lang.

Самый большой положительный конечный литерал типа float есть 3.40282347e+38f.Самый маленький положительный конечный литерал отличный от нуля типа float-1.40239846e-45f. Самый большой положительный конечный литерал типа double-1.79769313486231570e+308. Самый маленький положительный конечный литерал отличный от нуля типа double есть 4.94065645841246544e-324.

См. Float.MIN_VALUE (§20.9.1) и Float.MAX_VALUE (§20.9.2) ; см. также

Double.MIN_VALUE (§20.10.1) и Double.MAX_VALUE (§20.10.2).

Ошибка времени компиляции происходит в том случае, если вещественный литерал отличный от нуля слишком большой, так, что его преобразование во внутреннее представление IEEE 754 дает бесконечность. Программа на языке Ява может представлять бесконечность и без выдачи ошибки, используя константные выражения, такие как 1f/0f или - 1d/0d или, используя предопределенные константы POSITIVE_INFINITY и NEGATIVE_INFINITY классов Float (§20.9) и Double (§20.10).

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

Предопределенные константы, представляющие нечисловые значения определяются в классах Float и Double как в Float.NaN (§20.9.5) и Double.NaN (§20.10.5).

Примеры литералов типа float:

1e1f  2.f  .3f  0f  3.14f  6.022137e+23f
Примеры литералов типа double:
1e1  2.  .3  0.0  3.14  1e-9d  1e137

Нет никакого другого способа для выражения вещественных литералов кроме десятичной системы счисления. Однако, метод intBitsToFloat (§20.9.23) класса Float и метод longBitsToDouble (§20.10.22) класса Double обеспечивают путь к выражению значения с плавающей точкой в терминах шестнадцатиричного и восьмиричного целого литерала. Например, значение:

Double.longBitsToDouble(0x400921FB54442D18L)

равно значению Math.PI (§20.11.2).

3.10.3 Логические литералы

Тип boolean (логический тип) имеет два значения, представленные литералами true и false, сформированными из ASCII -букв.

Логический литерал имеет всегда тип boolean.

    BooleanLiteral: one of
    
    	true false
    

3.10.4 Символьные литералы

Символьный литерал представляется в виде символа или Unicode-последовательности, заключенной в ASCII одиночные кавычки. (Одиночная кавычка, или апостроф, знак \u0027.)

Символьный литерал имеет всегда тип char.

    CharacterLiteral:
    
    	' SingleCharacter '
    
    	' EscapeSequence '
    
    SingleCharacter:
    
    	InputCharacter кроме ' или \
    

Unicode- последовательности описываются в §3.10.6.

Как определено в §3.4, символы CR и LF не рассматриваются как InputCharacter; они распознаются по определению как LineTerminator.

Если за SingleCharacter или EscapeSequence следует символ, отличный от ‘, то это вызовет ошибку времени компиляции.

Ошибка времени компиляции происходит для ограничителя строки, появившейся после начала ' и перед концом '.

Далее рассмотрим примеры литералов типа char:

'a'
'%'
'\t'
'\\'
'\''
'\u03a9'
'\uFFFF'
'\177'
''
''

Поскольку Unicod-последовательности обрабатываются в первую очередь, было бы неверно писать '\u000a' для символьного литерала, чье значение - перевод строки; Unicode-последовательность \u000a преобразуется в фактический перевод строки на первом шаге преобразования (§3.3) и перевод строки станет LineTerminator на шаге 2 (§3.4) и таким образом на шаге 3 символьный литерал будет недопустимым. Вместо этого, нужно использовать управляющую последовательность '\n' (§ 3.10.6). Подобно этому, неправильно было бы писать'\u000d' для символьного литерала, чье значение - возврат каретки (CR). Вместо этого, используется '\r'.

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

3.10.5 Строковые литералы

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

Строковый литерал всегда имеет тип String (§ 4.3.3, § 20.12) Строковый литерал всегда ссылается на экземпляр (§ 4.3.1) класса String.

    StringLiteral:
    
    	" StringCharactersopt "
    
    StringCharacters:
    
    	StringCharacter
    
    	StringCharacters StringCharacter
    
    StringCharacter:
    
    	InputCharacter кроме " или \
    
    	EscapeSequence
    

Unicode - последовательности описаны в §3.10.6.

Как определено в §3.4, ни один из символов CR и LF никогда не рассматривается как InputCharacter; а распознается как образование LineTerminator.

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

Длинный строковый литерал всегда может быть разбит на более короткие части и написан как выражение, использующее оператор конкатенации строки + (§15.17.1).

Далее следуют примеры строковых литералов:

 

 

""            // пустая строка
"\""         // строка, содержащая одну "
"This is a string"         // строка, содержащая 16 символов
"This is a" +               // фактически, строковое константное выражение,
"two-line string"          // сформированное из двух строковых литералов

Поскольку Unicode - последовательности обрабатываются в первую очередь, не следует писать "\u000a" для строкового литерала, содержащего одиночный перевод строки (LF); символ Unicod'а \u000a преобразуется в фактический перевод строки на 1 шаге трансляции (§3.3) и перевод строки становится LineTerminator на 2 шаге (§3.4), в итоге к третьему шагу значение строкового литерала оказывается потерянным. Вместо этого нужно писать "\n" (§3.10.6). Аналогично, неправильно писать "\u000d" для строкового литерала, содержащего одиночный возврат каретки (CR). Вместо этого нужно писать "\r".

Каждый строковый литерал - это ссылка (§4.3) на объект (§4.3.1, §12.5) класса String (§4.3.3, §20.12). Объекты String имеют постоянное значение. Строковые литералы - или, вообще, строки, которые являются значениями константных выражений (§15.27) - интернированы, чтобы сделать возможным сопоставление объектов с помощью метода String.intern (§20.12.47).

Таким образом, тестовая программа, состоящая из модуля компиляции (§7.3)

package testPackage;

class Test {
	public static void main(String[] args) {
		String hello = "Hello", lo = "lo";
		System.out.print((hello == "Hello") + " ");
		System.out.print((Other.hello == hello) + " ");
		System.out.print((other.Other.hello == hello) + " ");
		System.out.print((hello == ("Hel"+"lo")) + " ");
		System.out.print((hello == ("Hel"+lo)) + " ");
		System.out.println(hello == ("Hel"+lo).intern());
	}
}

class Other { static String hello = "Hello"; }

и модуль компиляции:

package other;

public class Other { static String hello = "Hello"; }

выводит следующее:

true true true true false true

Этот пример иллюстрирует шесть моментов:

  • Строковые литералы внутри одного и того же класса (§8) в одном и том же пакете (§7) ссылаются на один и тот же объект String (§4.3.1).
  • Строковые литералы внутри различных классов в одном и том же пакете ссылаются на один и тот же объект String.
  • Строковые литералы внутри различных классов в различных пакетах аналогично ссылаются на один и тот же объект String.
  • Строки, вычисленные константными выражениями (§15.27), вычисляются во время компиляции и затем обрабатываются, как будто бы они были литералами.
  • Строки, вычисленные во время выполнения, создаются вновь и отличаются от соответствующих литералов.
  • Результат явного преобразования с помощью метода intern вычисленной строки - та же самая строка, как любой существовавший ранее строковый литерал с тем же самым содержанием.

3.10.6 Unicode-последовательности для символьных и строковых литералов

Символьные и строковые Unicode-последовательности позволяют представлять некоторые из неграфических символов таких как одиночная кавычка, двойная кавычка, и символы обратной косой черты в символьных литералах (§10.4) и строковых литералах (§3.10.5).

    EscapeSequence:
    	\ b /* \u0008: забой BS*/
    
    	\ t /* \u0009: горизонтальная табуляция HT*/
    
    	\ n /* \u000a: перевод строки LF*/
    
    	\ f /* \u000c: перевод страницы FF */
    
    	\ r /* \u000d: возврат каретки CR */
    
    	\ " /* \u0022: двойная кавычка " */
    
    	\ ' /* \u0027: одиночная кавычка ' */
    
    	\ \ /* \u005c: наклонная черта влево \ */
    
    	OctalEscape
             /* от \u0000 до \u00ff: из восьмеричных */
    
    OctalEscape:
    
    	\ OctalDigit
    
    	\ OctalDigit OctalDigit
    
    	\ ZeroToThree OctalDigit OctalDigit
    
    OctalDigit: one of
    
    	0 1 2 3 4 5 6 7
    
    ZeroToThree: one of
    
    	0 1 2 3
    

 

Если символ после наклонной черты влево в Unicode не является символом из ASCII b, t, n, f, r, ", ', \, 0, 1, 2, 3, 4, 5, 6, или 7, то возникает ошибка во время компиляции. В Unicode \u обсуждались выше (§3.3). (Восьмеричные последовательности обеспечивают совместимость с Си, но могут выражать только Unicode значения от \u0000 до \u00FF, так что обычно предпочитают Unicode - последовательность .)

3.10.7 Null-литерал

Тип null имеет одно значение, нулевая ссылка, представляемая пустым литеральным указателем, который сформирован из символов ASCII. Нулевой литерал всегда имеет тип null.

    NullLiteral:
    
    	null
    

3.11 Разделители

Следующие девять символов ASCII являются в языке Ява разделителями (знаками пунктуации):

    Separator: one of
    
    ()   {   }   [   ]   ;   ,   .
    

 

3.12 Операции

Следующие 37 лексем являются знаками операций языка Ява. Они составлены из символов ASCII:

    Operator: one of
    
     =    >    <    !    ~        ?    :
    
              ==    <=   >=   != && || ++ --
    
              +    -  *   /  &   |    ^   %   << >> >>>
    
             +=   -=  *= /= &=  |=    ^=  %= <<= >>= >>>=
    

[ Назад | Оглавление | Далее ]










helloworld.ru © 2001-2018
Все права защищены
Rambler's Top100 TopList