...
Operand 2 | Operand 3 | Resultant type |
---|---|---|
type T | type T | type T |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
other numeric | other numeric | promoted type of the 2nd and 3rd operands |
T1 = boxing conversion (S1) | T2 = boxing conversion(S2) | apply capture conversion to lub(T1,T2) |
Due to the complicated nature of the rules used to determine the result type of a conditional expression and the potential for unintended type casting, it is recommended that the second and third operands of the conditional expression should always explicitly have the same type.
Noncompliant Code Example
This noncompliant example prints A6565
instead of AAA
.
The
...
print statement prints the value of alpha
as A
, which is of the char
type. The third operand '0', is a constant expression of type int
whose value can be represented as a char
and hence does not cause any numeric promotion.
...
However, this behavior depends on the value of the constant integer expression. Changing the value of the constant integer expression may lead to different behavior, as will be demonstrated in the second noncompliant code example.
Code Block | ||
---|---|---|
| ||
public class Expr { public static void main(String[] args) { char alpha = 'A'; int i = 0; System.out.print(true ? alpha : 0); System.out.print(true ? alpha : 12345); System.out.print(false ? i : alpha); } } |
Compliant Solution
This compliant solution recommends the use of the same types for the second and third operands of the conditional expressions. The clearer semantics help avoid confusion.
Code Block | ||
---|---|---|
| ||
public class Expr { public static void main(String[] args) { char alpha = 'A'; // Cast 0 as a char i = 0; to explicitly state that the type of the // conditional expression should be char. System.out.print(true ? alpha : ((char) 0)); } } |
Noncompliant Code Example
This noncompliant example prints 65
instead of A
.
The print statement prints 65
, the integer equivalent of A
. This is because of numeric promotion of the second operand alpha
to an int
, which happens because the third operand, the constant expression '12345', is an int
that cannot be represented as a char
.
Code Block | ||
---|---|---|
| ||
public class Expr { public static void main(String[] args) { char alpha = 'A';declare as char System.out.print(true ? alpha : 0) 12345); } } |
Compliant Solution
The compliant solution casts alpha
to int
to explicitly state the result type of the conditional expression. Note that while casting 12345
to type char
would ensure that both operands in the second nonconforming conditional expression have the same type (and result in A
being printed), it would result in data loss when 12345
is converted to a char
. Therefore the conforming example casts alpha
to int
, the wider of the operand types.
Code Block | ||
---|---|---|
| ||
public class Expr { public static void main(String[] args) { char alpha = 'A'; // Cast alpha as an int to explicitly state that the type of the // conditional expression should be int. System.out.print(true ? ((int) alpha) : 12345); } } |
Noncompliant Code Example
This noncompliant example prints 65
instead of A
.
The print statement prints 65
. This is because of numeric promotion of the second operand alpha
to an int
, which happens because the third operand, variable i
, is an int
.
Code Block | ||
---|---|---|
| ||
public class Expr { public static void main(String[] args) { char alpha = 'A'; int i = 0; System.out.print(falsetrue ? ialpha : alphai); } } |
...
Compliant Solution
This compliant solution declares i
as a char
, ensuring that the second and third operands of the conditional expression have the same type.
Code Block | ||
---|---|---|
| ||
public class Expr {
public static void main(String[] args) {
char alpha = 'A';
char i = 0; //declare as char
System.out.print(true ? alpha : i);
}
}
|
Risk Assessment
If the types of the second and third operands in a conditional expression are not the same then the result of the conditional expression may be unexpected.
...