-----------------------------------------------------------------------------------------------------------------------------------
说明:
A literal is the source code representation of a value of a primitive type (§4.2), the String type (§4.3.3), or the null type (§4.1).
---------------------------------------------------------------------------------------------------------------------------------------
文法:
Literal:
IntegerLiteral
FloatingPointLiteral
BooleanLiteral
CharacterLiteral
StringLiteral
NullLiteral
---------------------------------------------------------------------------------------------------------------------------------------
扩展一(Integer Literals):
------------------------------------------------------------------------------------------------------------------------
说明:
An integer literal may be expressed in decimal (base 10), hexadecimal (base 16), octal (base 8), or binary (base 2).
The largest decimal literal of type int is 2147483648 (2^31).
All decimal literals from 0 to 2147483647 may appear anywhere an int literal may
appear.
It is a compile-time error if a decimal literal of type int is larger than 2147483648 (2^31),
or if the decimal literal 2147483648 appears anywhere other than as the operand of the unary minus operator (§15.15.4).
The largest positive hexadecimal, octal, and binary literals of type int - each of which represents the decimal value 2147483647 (2^31-1) - are respectively:
• 0x7fff_ffff,
• 0177_7777_7777, and
• 0b0111_1111_1111_1111_1111_1111_1111_1111
The most negative hexadecimal, octal, and binary literals of type int - each of which represents the decimal value -2147483648 (-2^31) - are respectively:
• 0x8000_0000,
• 0200_0000_0000, and
• 0b1000_0000_0000_0000_0000_0000_0000_0000
-----------------------------------------------------------------------------------------------------------------------------
文法:
IntegerLiteral:
DecimalIntegerLiteral
HexIntegerLiteral
OctalIntegerLiteral
BinaryIntegerLiteral
DecimalIntegerLiteral:
DecimalNumeral IntegerTypeSuffix opt
HexIntegerLiteral:
HexNumeral IntegerTypeSuffix opt
OctalIntegerLiteral:
OctalNumeral IntegerTypeSuffix opt
BinaryIntegerLiteral:
BinaryNumeral IntegerTypeSuffix opt
IntegerTypeSuffix: one of
l L
-------------------------------------------------------------------------
DecimalNumeral:
0
NonZeroDigit Digits opt
NonZeroDigit Underscores Digits
Digits:
Digit
Digit DigitsAndUnderscores opt Digit
Digit:
0
NonZeroDigit
NonZeroDigit: one of
1 2 3 4 5 6 7 8 9
DigitsAndUnderscores:
DigitOrUnderscore
DigitsAndUnderscores DigitOrUnderscore
DigitOrUnderscore:
Digit
_
Underscores:
_
Underscores _
--------------------------------------------------------------------------
HexNumeral:
0x HexDigits
0X HexDigits
HexDigits:
HexDigit
HexDigit HexDigitsAndUnderscores opt HexDigit
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
HexDigitsAndUnderscores:
HexDigitOrUnderscore
HexDigitsAndUnderscores HexDigitOrUnderscore
HexDigitOrUnderscore:
HexDigit
_
----------------------------------------------------------------------------------
OctalNumeral:
0 OctalDigits
0 Underscores OctalDigits
OctalDigits:
OctalDigit
OctalDigit OctalDigitsAndUnderscores opt OctalDigit
OctalDigit: one of
0 1 2 3 4 5 6 7
OctalDigitsAndUnderscores:
OctalDigitOrUnderscore
OctalDigitsAndUnderscores OctalDigitOrUnderscore
OctalDigitOrUnderscore:
OctalDigit
_
-----------------------------------------------------------------------------------
BinaryNumeral:
0b BinaryDigits
0B BinaryDigits
BinaryDigits:
BinaryDigit
BinaryDigit BinaryDigitsAndUnderscores opt BinaryDigit
BinaryDigit: one of
0 1
BinaryDigitsAndUnderscores:
BinaryDigitOrUnderscore
BinaryDigitsAndUnderscores BinaryDigitOrUnderscore
BinaryDigitOrUnderscore:
BinaryDigit
_
------------------------------------------------------------------------------------------------------------------------------------------
扩展二(Floating-Point Literals):
-------------------------------------------------------------------------------------------------------------------------------------
说明:
A floating-point literal is of type float if it is suffixed with an ASCII letter F or f;
otherwise its type is double and it can optionally be suffixed with an ASCII letter D or d.
The elements of the types float and double are those values that can be represented using the IEEE 754 32-bit single-precision
and 64-bit double-precision binary floating-point formats, respectively.
The details of proper input conversion from a Unicode string representation of a floating- point number to the internal IEEE 754 binary floating-point
representation are described for the methods valueOf of class Float and class Double of the package java.lang.
The largest positive finite literal of type float is 3.4028235e^38f.
The smallest positive finite non-zero literal of type float is 1.40e^-45f.
The largest positive finite literal of type double is 1.7976931348623157e^308.
The smallest positive finite non-zero literal of type double is 4.9e^-324.
It is a compile-time error if a non-zero floating-point literal is too large, so that on rounded conversion to its internal representation, it becomes an IEEE 754 infinity.
A program can represent infinities without producing a compile-time error by using constant expressions such as 1f/0f or -1d/0d or
by using the predefined constants POSITIVE_INFINITY and NEGATIVE_INFINITY of the classes Float and Double.
It is a compile-time error if a non-zero floating-point literal is too small, so that, on rounded conversion to its internal representation, it becomes a zero.
-------------------------------------------------------------------------------------------------------------------------------
文法:
FloatingPointLiteral:
DecimalFloatingPointLiteral
HexadecimalFloatingPointLiteral
DecimalFloatingPointLiteral:
Digits . Digits opt ExponentPart opt FloatTypeSuffix opt
. Digits ExponentPart opt FloatTypeSuffix opt
Digits ExponentPart FloatTypeSuffix opt
Digits ExponentPart opt FloatTypeSuffix
ExponentPart:
ExponentIndicator SignedInteger
ExponentIndicator: one of
e E
SignedInteger:
Sign opt Digits
Sign: one of
+ -
FloatTypeSuffix: one of
f F d D
HexadecimalFloatingPointLiteral:
HexSignificand BinaryExponent FloatTypeSuffix opt
HexSignificand:
HexNumeral
HexNumeral .
0x HexDigitsopt . HexDigits
0X HexDigitsopt . HexDigits
BinaryExponent:
BinaryExponentIndicator SignedInteger
BinaryExponentIndicator:one of
p P
-------------------------------------------------------------------------------------------------------------------------------------
例子:
Examples of float literals:
1e1f 2.f .3f 0f 3.14f 6.022137e+23f
Examples of double literals:
1e1 2. .3 0.0 3.14 1e-9d 1e137
------------------------------------------------------------------------------------------------------------------------------------
扩展三(Boolean Literals):
-----------------------------------------------------------------------------------------------------------------------
说明:
The boolean type has two values, represented by the boolean literals true and
false , formed from ASCII letters.
A boolean literal is always of type boolean .
-------------------------------------------------------------------------------------------------------------------------
文法:
BooleanLiteral: one of
true false
-----------------------------------------------------------------------------------------------------------------------------------------
扩展四(Character Literals):
------------------------------------------------------------------------------------------------------------------------
说明:
A character literal is expressed as a character or an escape sequence (§3.10.6),
enclosed in ASCII single quotes. (The single-quote, or apostrophe, character is
\u0027 .)
Character literals can only represent UTF-16 code units (§3.1), i.e., they are limited
to values from \u0000 to \uffff . Supplementary characters must be represented
either as a surrogate pair within a char sequence, or as an integer, depending on
the API they are used with.
A character literal is always of type char .
It is a compile-time error for the character following the SingleCharacter or
EscapeSequence to be other than a ‘ .
It is a compile-time error for a line terminator (§3.4) to appear after the opening
‘ and before the closing ‘ .
注:
Because Unicode escapes are processed very early, it is not correct to write ‘\u000a‘
for a character literal whose value is linefeed (LF); the Unicode escape \u000a is
transformed into an actual linefeed in translation step 1 (§3.3) and the linefeed becomes a
LineTerminator in step 2 (§3.4), and so the character literal is not valid in step 3. Instead,
one should use the escape sequence ‘\n‘ (§3.10.6). Similarly, it is not correct to write
‘\u000d‘ for a character literal whose value is carriage return (CR). Instead, use ‘\r‘ .
---------------------------------------------------------------------------------------------------------------------------
文法:
CharacterLiteral:
‘ SingleCharacter ‘
‘ EscapeSequence ‘
SingleCharacter:
InputCharacter but not ‘ or --------------------------------------------------------------------------------------------------------------------------------
使用例子:
• ‘a‘
• ‘%‘
• ‘\t‘
• ‘\\‘
• ‘\‘‘
• ‘\u03a9‘
• ‘\uFFFF‘
• ‘\177‘
• ‘Ω‘
• ‘⊗‘
-------------------------------------------------------------------------------------------------------------------------------------------
扩展五(String Literals):
--------------------------------------------------------------------------------------------------------------------------------------
说明:
A string literal consists of zero or more characters enclosed in double quotes.
Characters may be represented by escape sequences (§3.10.6) - one escape
sequence for characters in the range U+0000 to U+FFFF, two escape sequences
for the UTF-16 surrogate code units of characters in the range U+010000 to U
+10FFFF.
It is a compile-time error for a line terminator to appear after the opening " and
before the closing matching " .
As specified in §3.4, the characters CR and LF are never an InputCharacter; each is
recognized as constituting a LineTerminator.
A long string literal can always be broken up into shorter pieces and written as a (possibly
parenthesized) expression using the string concatenation operator + (§15.18.1).
Because Unicode escapes are processed very early, it is not correct to write "\u000a"
for a string literal containing a single linefeed (LF); the Unicode escape \u000a is
transformed into an actual linefeed in translation step 1 (§3.3) and the linefeed becomes
a LineTerminator in step 2 (§3.4), and so the string literal is not valid in step 3. Instead,
one should write "\n" (§3.10.6). Similarly, it is not correct to write "\u000d" for a string
literal containing a single carriage return (CR). Instead, use "\r" . Finally, it is not possible
to write "\u0022" for a string literal containing a double quotation mark (").
A string literal is a reference to an instance of class String (§4.3.1, §4.3.3).
Moreover, a string literal always refers to the same instance of class String . This
is because string literals - or, more generally, strings that are the values of constant
expressions (§15.28) - are "interned" so as to share unique instances, using the
method String.intern .
注:
Because Unicode escapes are processed very early, it is not correct to write "\u000a"
for a string literal containing a single linefeed (LF); the Unicode escape \u000a is
transformed into an actual linefeed in translation step 1 (§3.3) and the linefeed becomes
a LineTerminator in step 2 (§3.4), and so the string literal is not valid in step 3. Instead,
one should write "\n" (§3.10.6). Similarly, it is not correct to write "\u000d" for a string
literal containing a single carriage return (CR). Instead, use "\r" . Finally, it is not possible
to write "\u0022" for a string literal containing a double quotation mark (").
-------------------------------------------------------------------------------------------------------------------------------------------
文法:
StringLiteral:
" StringCharacters opt "
StringCharacters:
StringCharacter
StringCharacters StringCharacter
StringCharacter:
InputCharacter but not " or EscapeSequence
See §3.10.6 for the definition of EscapeSequence.
----------------------------------------------------------------------------------------------------------------------------------
使用例子:
"" //the empty string
"\"" //a string containing " alone
"This is a string" //a string containing 16 characters
"This is a " + //actually a string-valued constant expression,
"two-line string" // formed from two string literals
----------------------------------------------------------------------------------------------------------------------------------
扩展一(使相同的字符串文法运算结果表示相同的对象):
-----------------------------------------------------------------------------------------------------------
语法:
String.intern
-------------------------------------------------------------------------------------------------------------
说明:
A string literal is a reference to an instance of class String (§4.3.1, §4.3.3).
Moreover, a string literal always refers to the same instance of class String . This
is because string literals - or, more generally, strings that are the values of constant
expressions (§15.28) - are "interned" so as to share unique instances, using the
method String.intern .
--------------------------------------------------------------------------------------------------------------
使用例子:
The program consisting of the compilation unit (§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"; }
and the compilation unit:
package other;
public class Other { public static String hello = "Hello"; }
produces the output:
true true true true false true
说明:
• Literal strings within the same class (§8) in the same package (§7) represent references
to the same String object (§4.3.1).
• Literal strings within different classes in the same package represent references to the
same String object.
• Literal strings within different classes in different packages likewise represent references
to the same String object.
• Strings computed by constant expressions (§15.28) are computed at compile time and
then treated as if they were literals.
• Strings computed by concatenation at run-time are newly created and therefore distinct.
• The result of explicitly interning a computed string is the same string as any pre-existing
literal string with the same contents.
--------------------------------------------------------------------------------------------------------------------------------------
扩展六(Escape Sequences for Character and String Literals):
-------------------------------------------------------------------------------------------------------------------------------------
说明:
The character and string escape sequences allow for the representation of some nongraphic characters as well as the single quote,
double quote, and backslash characters in character literals (§3.10.4) and string literals (§3.10.5).
It is a compile-time error if the character following a backslash in an escape is not an ASCIIb,t,n,f,r,",‘,\,0,1,2,3,4,5,6, or7. The Unicode escape\u is processed earlier (§3.3).
Octal escapes are provided for compatibility with C, but can express only Unicode values \u0000 through \u00FF, so Unicode escapes are usually preferred.
-----------------------------------------------------------------------------------------------------------------------------------
文法:
EscapeSequence:
\b /* \u0008: backspace BS */
\t /* \u0009: horizontal tab HT */
\n /* \u000a: linefeed LF */
\f /* \u000c: form feed FF */
\r /* \u000d: carriage return CR */
\" /* \u0022: double quote " */
\‘ /* \u0027: single quote ‘ */
\\ /* \u005c: backslash \ */
OctalEscape /* \u0000 to \u00ff: from octal value */
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
-----------------------------------------------------------------------------------------------------------------------------------------------
扩展七(The Null Literal):
------------------------------------------------------------------------------------------------------------------------------
说明:
The null type has one value, the null reference, represented by the null literal null, which is formed from ASCII characters.
A null literal is always of the null type.
-------------------------------------------------------------------------------------------------------------------------------------
文法:
NullLiteral:
null
时间： 2024-10-13 04:58:08