Only atomic pieces of expressions (e.g., the literal
true) have a type. Composite expressions don’t have a type.
Expressions that consist of multiple parts have no type
Expressions that consist of multiple parts have a type
CorrectionHere is what's right.
The type of a composite expression is determined by the operator’s (or method’s) result type.
For example, the expression
1+2 has type
+ operator on two
int operands produces an
and the expression
Math.sin(2.5) has type
Math.sin(double) has the return type
ValueHow can you build on this misconception?
This misconception provides an interesting starting point for discussions on the structure of expressions (e.g., that even a single literal is an expression), on static typing, and on how exactly the type of an expression is determined at compile time.
Determining the Type of an Expressions
Many expressions in Java are so-called standalone expressions: their type can be determined entirely based on their source code.
However, some language features (like lambdas) lead to some expressions not being standalone expressions. Those expressions are so-called poly expressions, and their type has to be determined also from their context (the source code surrounding the expression).
An example of a standalone expression is
x * 2:
its type can be determined without looking at its surrounding code
(except for looking at the declaration of variable x to find the type of x).
Assume the type of variable
The expression will have the same type no matter
whether it is placed in
long l = ___
Math.sin(___) or in
float f = ___.
An example of a poly expression is
x -> x:
its type cannot be determined without looking at its surrounding code.
For example, the type could be
if placed in
Function<Double,Double> f = ___,
or it could be
Function<Pair,Pair> if placed in