Course contentsShow
← Java
Lesson 128 of 2,8703. Operators and ExpressionsFree lesson

Nesting Ternary Operators: Readability Considerations

Explore how to nest ternary operators for multi-way decisions and why deeply nested ternaries often hurt code clarity.

Nesting Ternary Operators: Readability Considerations

What you'll learn: How to chain multiple ternary operators together and why this often makes code harder to understand.

The Core Idea

Since the ternary operator returns a value, you can use another ternary operator as one of its branches. This creates a nested ternary that handles multiple conditions in a single expression. While technically valid, deeply nested ternaries quickly become difficult to read and maintain.

Basic Nesting Example

int score = 85;
String grade = score >= 90 ? "A" :
               score >= 80 ? "B" :
               score >= 70 ? "C" : "F";
// grade is "B"

This checks multiple conditions sequentially. If score >= 90 is false, it evaluates the second ternary (score >= 80 ? "B" : ...), and so on.

The Readability Problem

Compare the nested ternary above to an equivalent structure:

String grade;
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else {
    grade = "F";
}

The if-else version is longer but far clearer about the decision logic.

When Nesting Goes Wrong

int x = 5, y = 10, z = 3;
int result = x > y ? x > z ? x : z : y > z ? y : z;

This finds the maximum of three numbers, but it's a puzzle to decipher. Deeply nested ternaries force readers to mentally parse precedence and branches.

Key Takeaway: While you can nest ternary operators for multi-way decisions, limit nesting to simple cases. For complex logic with three or more branches, if-else statements are almost always more readable and maintainable.