Java Ternary-Operator

Der Ternary-Operator ?: ist Javas einziger Operator mit drei Operanden. Er ist eine kompakte if/else-Variante für Ausdrücke, keine Anweisung – das heißt, er liefert einen Wert, den du zuweisen, zurückgeben oder als Argument übergeben kannst. Diese Seite erklärt die Syntax, wo er gut lesbar ist, die Typregeln für die beiden Zweige und wann stattdessen if/else oder switch sinnvoller ist.

Syntax

condition ? valueIfTrue : valueIfFalse

Ist condition true, ergibt der gesamte Ausdruck valueIfTrue. Andernfalls ergibt er valueIfFalse. Java berechnet genau einen der beiden Werte.

int age = 20;
String status = (age >= 18) ? "adult" : "minor";
System.out.println(status);   // adult

Die Klammern um die Bedingung sind optional; viele Style-Guides empfehlen sie aus Gründen der Lesbarkeit.

Wo er glänzt

Der Ternary-Operator ist am besten geeignet für einmalige Zuweisungen oder als Teil eines größeren Ausdrucks, wo ein if/else einen Zeilenumbruch erfordern würde:

int max = (a > b) ? a : b;
String label = items.isEmpty() ? "no items" : items.size() + " items";
System.out.println("Hello, " + (name != null ? name : "stranger") + "!");

Die letzte Form ist besonders praktisch: Sie ermöglicht es, inline einen Wert auszuwählen, ohne eine temporäre Variable einführen zu müssen.

Typen müssen kompatibel sein

Beide Zweige eines Ternary-Operators müssen kompatible Typen liefern. Der Compiler wählt den allgemeinsten gemeinsamen Typ für den gesamten Ausdruck:

int x = 5;
double d = (x > 0) ? x : 0.0;   // result type is double

Wirklich inkompatible Zweige – bei denen kein Wert in den anderen konvertiert werden kann und der Zieltyp nicht beide aufnehmen kann – verursachen einen Compilerfehler:

// won't compile: String cannot be converted to int
int n = condition ? 1 : "two";

Zwei nicht verwandte Referenztypen sind hingegen in Ordnung, wenn der Zieltyp allgemein genug ist, um beide Ergebnisse aufzunehmen. Hier werden beide Zweige auf ihren gemeinsamen Obertyp Object erweitert:

Object value = condition ? "yes" : 42;   // 42 is autoboxed to Integer; type is Object

Wenn du einen bestimmten Typ benötigst, caste einen der Zweige, damit der abgeleitete Typ deinen Erwartungen entspricht.

Keine tiefen Verschachtelungen

Du kannst Ternary-Operatoren verschachteln – aber ab einer Ebene wird es schwer lesbar:

String grade = (score >= 90) ? "A"
             : (score >= 80) ? "B"
             : (score >= 70) ? "C"
             : "F";

Das ist schon grenzwertig; viele Teams verbieten selbst das. Bei mehr als zwei Zweigen ist eine if/else if-Kette oder ein switch fast immer klarer. Verwende den Ternary-Operator nur, wenn es genau zwei Ergebnisse gibt.

Ternary vs. if/else

Beide kompilieren im Wesentlichen zum gleichen Bytecode, daher ist es keine Leistungsfrage – sondern eine Frage der Lesbarkeit. Die Faustregeln:

• Verwende einen Ternary-Operator, wenn du einen Wert brauchst – zum Zuweisen, Zurückgeben oder Interpolieren.
• Verwende if/else, wenn du Anweisungen brauchst – Seiteneffekte, mehrere Zeilen, Logging.

// good ternary use:
return (errors == 0) ? "OK" : "FAIL";

// bad ternary use — side effects in branches:
boolean ok = (x > 0) ? logSuccess() : logFailure();

Das zweite Beispiel funktioniert zwar, aber Seiteneffekte in einem bedingten Ausdruck zu verstecken, verschleiert den Kontrollfluss. Schreibe es stattdessen mit if/else aus.

Null-sichere Standardwerte

Ein häufiges Muster: Rückfall auf einen Standardwert, wenn etwas null ist:

String displayName = (user.name != null) ? user.name : "Anonymous";

Wenn du dieses Muster häufig verwendest, bietet das JDK einen Helfer – Objects.requireNonNullElse:

import java.util.Objects;

String displayName = Objects.requireNonNullElse(user.name, "Anonymous");

Ein praktisches Beispiel

Was kommt als Nächstes

Für die Auswahl aus vielen Fällen anhand eines einzelnen Wertes ist die switch-Anweisung lesbarer als eine lange Ternary-Kette. Für anweisungsbasierte Verzweigungen mit Seiteneffekten verwende if/else, und die vollständige Übersicht über Vergleichs- und logische Operatoren findest du unter Java-Operatoren.

Übungen