A compile-time constant expression is an expression denoting a value of primitive type or a String
that does not complete abruptly and is composed using only the following:
Literals of primitive type and literals of type
String
(§3.10.5)
Casts to primitive types and casts to type
String
The unary operators
+
,
-
,
~
, and
!
(but not
++
or
--
)
The multiplicative operators
*
,
/
, and
%
The additive operators
+
and
-
The shift operators
<<
,
>>
, and
>>>
The relational operators
<
,
<=
,
>
, and
>=
(but not
instanceof
)
The equality operators
==
and
!=
The bitwise and logical operators
&
,
^
, and
|
The conditional-and operator
&&
and the conditional-or operator
||
The ternary conditional operator
?
:
Parenthesized expressions whose contained expression is a constant expression.
Simple names that refer to constant variables
(§4.12.4) .
Qualified names of the form
TypeName
.
Identifier that refer to constant variables
(§4.12.4) .
Compile-time constant expressions are used in case
labels in switch
statements (§14.11) and have a special significance for assignment conversion (§5.2) . Compile-time constants of type String
are always "interned" so as to share unique instances, using the method String.intern.
A compile-time constant expression is always treated as FP-strict (§15.4) , even if it occurs in a context where a non-constant expression would not be considered to be FP-strict.
Examples of constant expressions:
true (short)(1*2*3*4*5*6) Integer.MAX_VALUE / 2 2.0 * Math.PI "The integer " + Long.MAX_VALUE + " is mighty big."
其中complete abruptly就是指突然结束,比如抛出一个异常之类