Conditional

The ?: operator, formally known as the conditional operator, is the only ternary operator in Java. It functions as an expression-level control flow construct that evaluates a boolean condition and yields one of two mutually exclusive expressions based on the boolean result. Because it is an expression, it resolves to a single compile-time type and evaluates to a value at runtime, meaning it cannot execute void methods or standalone statements.

booleanExpression ? expressionIfTrue : expressionIfFalse

Evaluation Mechanics

1. First Operand (booleanExpression): Must evaluate to a primitive boolean or the Boolean wrapper class. If a Boolean object is provided and is null, Java will attempt to unbox it, resulting in a NullPointerException.
2. Second and Third Operands (expressionIfTrue, expressionIfFalse): Must be expressions that return a value.
3. Short-Circuiting: The operator guarantees short-circuit evaluation. If the first operand evaluates to true, only the second operand is evaluated. If it evaluates to false, only the third operand is evaluated. Side effects in the unselected operand will not occur.

int x = 5;
int y = 10;

// The division (y / 0) is never evaluated, preventing an ArithmeticException
int result = (x == 5) ? y : (y / 0); 

Type Resolution and Promotion Rules

The compile-time return type of the ternary expression is determined by the types of the second and third operands. Java applies specific type promotion and resolution rules (JLS §15.25) during compilation:

• Identical Types: If both operands are of the exact same type, the expression’s return type is that type.
• Primitive and Wrapper: If one operand is a primitive type and the other is its corresponding wrapper class (e.g., int and Integer), the wrapper is unboxed, and the expression’s return type is the primitive type.
• Specific Numeric Exceptions: If one operand is of type byte (or Byte) and the other is of type short (or Short), the type of the conditional expression resolves to short.
• Constant Expression Exception: If one operand is a byte, short, or char, and the other is a constant int expression whose value is representable in that smaller type, the expression resolves to the smaller type.
• Binary Numeric Promotion: For other mixed numeric types, Java applies standard binary numeric promotion. The expression resolves to the promoted type of the two operands (e.g., short and int resolves to int; int and double resolves to double).
• Reference Types: If the operands are different reference types, the compiler computes the least upper bound of the two types. If the classes share multiple interfaces, this results in an intersection type (e.g., Serializable & Comparable) rather than a single most specific class or interface.

byte b = 1;
short s = 2;
int i = 3;
Integer wrapperInt = null;

// Specific numeric exception: byte and short resolve to short.
short byteShortResult = true ? b : s;

// Binary numeric promotion: short and int resolve to int.
int promotedResult = true ? s : i;

// Constant expression exception: 0 is a constant int representable as a short.
// The result type is short, not int.
short constResult = true ? s : 0;

// Unboxing rule: The result type is primitive int.
// Because the expression resolves to int, 'wrapperInt' is unboxed.
// Throws NullPointerException at runtime because wrapperInt is null.
int unboxedResult = false ? 0 : wrapperInt; 

// Reference types: The least upper bound of String and Integer 
// is the intersection type: Serializable & Comparable<? extends Object>
var intersectionResult = true ? "Text" : 42;

Associativity

The ?: operator is right-associative. When multiple conditional operators are chained in a single expression without explicit parentheses, they are grouped and evaluated from right to left.

// Syntax
a ? b : c ? d : e

// Implicit grouping due to right-associativity
a ? b : (c ? d : e)

Master Java with Deep Grasping Methodology!

Learn More