2.8 Dokumentationskommentare 

Die Dokumentation von Softwaresystemen ist ein wichtiger, aber oft vernachlässigter Teil der Softwareentwicklung. Im Entwicklungsprozess müssen die Entwickler Zeit in Beschreibungen der einzelnen Komponenten investieren, besonders dann, wenn weitere Entwickler diese Komponenten wieder verwerten. Diese Wiederverwertung wird besonders bei der objektorientierten Programmierung angestrebt. Deshalb müssen die Schnittstellen sorgfältig beschrieben werden. Wichtig bei der Beschreibung sind die Art und die Anzahl der Parameter, die Wirkung der Funktionen und das Laufzeitverhalten. Da das Erstellen einer externen Dokumentation – also einer Beschreibung außerhalb der Quellcodedatei – fehlerträchtig und deshalb nicht gerade motivierend für die Beschreibung ist, werden spezielle Anweisungen in den Java-Quelltext eingeführt. Ein spezielles Programm generiert aus den Formatierungsanweisungen eine Textdatei mit den gewünschten Informationen.¹ 

2.8.1 Ein Dokumentationskommentar setzen 

In einer besonders ausgezeichneten Kommentarumgebung werden die Beschreibungen, die Dokumentationskommentare (»Doc Comments«) genannt werden, eingesetzt. Die Kommentarumgebung ähnelt dem Blockkommentar.

/**
 * Socken sind spezielle Kleidungsstücke.
 */
public class Socke extends Kleidung
{
}

Da ein Dokumentationskommentar /** mit /* beginnt, ist es für den Compiler ein normaler Blockkommentar. Die Kommentare werden oft optisch aufgewertet, indem am Anfang ein Sternchen steht. Dieses wird von JavaDoc ignoriert. Der Dokumentationskommentar beschreibt Methoden- und Klassendefinitionen.

2.8.2 Mit javadoc eine Dokumentation erstellen 

Um eine Dokumentation zu erzeugen, wird dem Konsolen-Programm javadoc als Parameter ein Dateiname der zu kommentierenden Klasse übergeben; aus compilierten Dateien können natürlich keine Beschreibungsdateien erstellt werden. Wir starten javadoc im Verzeichnis, in dem auch die Klassen liegen, und erhalten unsere HTML-Dokumente.

Listing 2.11   Kleidung.java

/**
 *  Kleidung bildet die Oberklasse für alle Kleidungs-Objekte.
 */
import java.io.*;
public abstract class Kleidung implements Serializable
{
  /**
   *  Jede Kleidung hat eine Farbe.
   */
  protected String farbe;
  /**
   *  Erzeugt neues Kleidungs-Objekt.
   */
  protected Kleidung()
  {
  }
  /**
   *  Erzeugt neues Kleidungs-Objekt,
   *  welches mit einer Farbe initialisiert wird.
   */
  protected Kleidung( String farbe )
  {
    this.farbe = farbe;
  }
  /**
   *  Jede Kleidung hat einen Namen.
   *  Wird von Unterklassen überschrieben.
   */
   abstract String getName();
}

/**
 *   Das ist ein kurzer Satz.
 *   Das ist die ausführliche Beschreibung.
 *   Die ausführliche Beschreibung erscheint
 *   später im Abschnitt "Method Detail".
 *   Der kurze Satz erscheint im Abschnitt "Method Summary".
 */
public void foo() { }

Listing 2.12   Socke.java

/**
 *  Socken sind spezielle Kleidungsstücke.
 */
import java.io.*;
public class Socke extends Kleidung implements Serializable
{
  /**
   *  Erzeugt ein neues Socken-Objekt mit der Farbe Schwarz.
   */
   Socke()
   {
     super( "schwarz" );
   }
   /**
    *  Überschrieben von der Oberklasse.
    */
    public String getName()
    {
      return "Socke";
    }
}

JavaDoc geht durch den Quelltext und parst die Deklarationen und zieht die Dokumentation heraus. Daraus generiert das Tool eine Beschreibung, die in der Regel als HTML-Seite zu uns kommt.

$ javadoc *.java

Hier klicken, um das Bild zu Vergrößern

In Eclipse lässt sich eine Dokumentation mit JavaDoc sehr einfach erstellen. Im Menü File, Export ist der Eintrag Javadoc zu wählen und nach ein paar Einstellungen ist die Dokumentation generiert.

HTML-Tags in Dokumentationskommentaren

In den Kommentaren können HTML-Tags verwendet werden, beispielsweise <b>..</b> und <i>..</i>, um Textattribute zu setzen. Sie werden direkt in die Dokumentation übernommen, müssen also korrekt geschachtelt sein, damit die Ausgabe nicht falsch dargestellt wird. Die Überschriften-Tags <h1>..</h1> und <h2>..</h2> sollten jedoch nicht verwendet werden. JavaDoc verwendet sie zur Gliederung der Ausgabe und weist ihnen Formatvorlagen zu.

2.8.3 Generierte Dateien 

Für jede öffentliche Klasse erstellt JavaDoc eine HMTL-Datei. Sind Klassen nicht öffentlich, muss ein Schalter angegeben werden. Die HTML-Dateien werden zusätzlich mit Querverweisen zu den anderen dokumentierten Klassen versehen. Daneben erstellt JavaDoc weitere Dateien:

index-all.html Die Übersicht aller Klassen, Schnittstellen, Ausnahmen, Methoden und Felder in einem Index

overview-tree.html Zeigt in einer Baumstruktur die Klassen an, damit die Vererbung deutlich sichtbar ist.

allclasses-frame.html Anzeige aller dokumentierten Klassen in allen Unterpaketen

deprecated-list.html Liste der veralteten Methoden und Klassen

serialized-form.html Listet alle Klassen auf, die Serializable implementieren. Jedes Attribut erscheint mit einer Beschreibung in einem Absatz.

help-doc.html Eine Kurzbeschreibung von JavaDoc

index.html JavaDoc erzeugt eine Ansicht mit Frames. Das ist die Hauptdatei, die die rechte und linke Seite referenziert. Die linke Seite ist die Datei allclasses-frame.html. Rechts im Frame wird bei fehlender Paketbeschreibung die erste Klasse angezeigt.

stylesheet.css Formatvorlage für HTML-Dateien, in der sich Farben und Zeichensätze einstellen lassen, die dann alle HTML-Dateien nutzen.

packages.html Eine veraltete Datei. Sie verweist auf die neuen Dateien.

2.8.4 Weitere Dokumentationskommentare 

Beispiele

@see <a href="spec.html#section">Java Spec</a>.

@see String#equals(Object) equals

/**
 * The X-coordinate of the component.
 *

* @see #getLocation()
 */
 int x = 1263732;

/**
 * @deprecated  As of JDK 1.1,
 * replaced by {@link #setBounds(int,int,int,int)}
 */

2.8.5 Schalter für das Programm javadoc 

Über die umfangreichen Parameter von Javadoc informiert eine HTML-Datei, die dem Java-SDK beigelegt ist.

WINDOWTITLE = ’Java Platform 1.2 Final API Specification’
DOCTITLE = ’Java<sup><font size="-2">TM</font></sup> Platform 1.2 Final\
 API Specification’
HEADER = ’<b>Java Platform 1.2</b><br><font size="-1">Final</font>’
BOTTOM = ’<font size="-1"><a href="http://java.sun.com/cgi-bin/\
 bugreport.cgi">Submit a bug or feature</a><br><br>Java is a\
 trademark or registered trademark of Sun Microsystems, Inc. in the\
 US and other countries.<br>Copyright 1993–1998 Sun Microsystems,\
 Inc. 901 San Antonio Road,<br>Palo Alto, California, 94303, U.S.A.\
 All Rights Reserved.</font>’
GROUPCORE = ’"Core Packages" "java.*:com.sun.java.*:org.omg.*"
GROUPEXT  = ’"Extension Packages" "javax.*"’
javadoc -sourcepath /jdk/src/share/classes \
        -d /jdk/build/api                  \
        -use                               \
        -splitIndex                        \
        -windowtitle $(WINDOWTITLE)        \
        -doctitle $(DOCTITLE)              \
        -header $(HEADER)                  \
        -bottom $(BOTTOM)                  \
        -group $(GROUPCORE)                \
        -group $(GROUPEXT)                 \
        -overview overview-core.html       \
        -J-Xmx180m                         \
        java.lang java.lang.reflect        \
        java.util java.io java.net         \
        java.applet                        \

2.8.6 JavaDoc und Doclets 

Die Ausgabe von JavaDoc kann den eigenen Bedürfnissen angepasst werden, indem Doclets eingesetzt werden. Ein Doclet ist ein Java-Programm, das auf der Doclet-API aufbaut und die Ausgabedatei schreibt. Das Programm liest dabei wie das bekannte JavaDoc-Tool die Quelldateien ein und erzeugt daraus ein beliebiges Ausgabeformat. Dieses Format kann selbst gewählt und implementiert werden. Wer also neben dem von JavaSoft beigefügten Standard-Doclet für HTML-Dateien Framemaker-Dateien (MIF) oder RTF-Dateien erzeugen möchte, muss nur ein eigenes Doclet programmieren. Daneben dient ein Doclet aber nicht nur der Schnittstellendokumentation. Ein Doclet kann auch dokumentieren, ob es zu jeder Methode auch eine Dokumentation gibt oder ob jeder Parameter und jeder Rückgabewert beschrieben ist.2.8Weitere Operatoren

2.8.7 Bitoperationen 

Zahlen und Werte sind im Computer als Sammlung von Bits gegeben. Ein Bit ist ein Informationsträger für die Aussage wahr oder falsch. Bits werden zusammengesetzt zu Folgen wie einem Byte, das aus acht Bits besteht. Die Belegung der Bits ergibt einen Wert. Da jeder der acht Bits unterschiedliche Belegungen annehmen kann, ergeben sich 256 unterschiedliche Zahlen. Ist kein Bit gesetzt, so ist die Zahl 0. Jede Stelle im Byte bekommt dabei eine Wertigkeit zugeordnet.

Mit Bitoperatoren lassen sich Binäroperationen auf Operanden durchführen, um beispielsweise Bits eines Worts zu setzen. Zu den Bitoperationen zählen Verknüpfungen, Schiebeoperationen und das Komplement. Durch die bitweisen Operatoren können die einzelnen Bits abgefragt und manipuliert werden. Als Verknüpfungen bietet Java die folgenden Bitoperatoren an:

Betrachten wir allgemein die binäre Verknüpfung a # b. Bei der binären bitweisen Und-Verknüpfung mit & gilt für jedes Bit: Nur wenn beide Operanden a und b 1 sind, dann ist auch das Ergebnis 1. Bei der Oder-Verknüpfung mit | muss nur einer der Operanden 1 sein, damit das Ergebnis 1 ist. Bei einem exklusiven Oder (Xor) ist das Ergebnis 1, wenn nur genau einer der Operanden 1 ist. Sind beide gemeinsam 0 oder 1, ist das Ergebnis 0. Dies entspricht einer binären Addition oder Subtraktion. Fassen wir das Ergebnis noch einmal in einer Tabelle zusammen:

2.8.8 Vorzeichenlose Bytes in ein Integer und Char konvertieren 

Liegt ein Byte als Datentyp vor, so kann es zwar automatisch zu einem int angepasst werden, aber die automatische Typkonvertierung erfüllt nicht immer den gewünschten Zweck.

byte b1 =       100;
byte b2 = (byte)200;

System.out.println( b1 );                  // 100
System.out.println( b2 );                  // –56

Beim zweiten Byte ist eine Typanpassung nötig, da 0x90 größer als 0x7f ist und daher den Zahlenbereich eines Byte –128 bis 127 überschreitet. Dennoch kann ein Byte das gegebene Bitmuster annehmen und repräsentiert dann die negative Zahl –56. Wird diese ausgegeben, findet bei println(int) eine automatische Typanpassung auf ein int statt und die negative Zahl als byte wird zur negativen int-Zahl. Das bedeutet, dass das Vorzeichen übernommen wird. In einigen Fällen ist es jedoch wünschenswert, ein byte vorzeichenlos zu behandeln. Bei der Ausgabe soll dann ein Datenwert zwischen 0 und 255 herauskommen. Um das zu erreichen, schneiden wir mit der Und-Verknüpfung – alle anderen Bits ausgenommen – die unteren acht heraus. Das reicht schon. Die Lösung zeigt die Funktion byteToInt():

static int byteToInt( byte b )
{
  return b & 0xff;
}

Die Schreibweise (int)b ist nicht nötig, da die automatische Typanpassung das Byte b in einer arithmetischen Operation automatisch auf ein int konvertiert.

Mit einer ähnlichen Arbeitsweise können wir auch die Frage lösen, wie sich ein Byte, dessen Integerwert im Minusbereich liegt, in ein char konvertieren lässt. Der erste Ansatz über eine Typumwandlung (char)byte ist falsch, und auf der Ausgabe dürfte nur ein rechteckiges Kästchen oder ein Fragezeichen erscheinen:

byte b = (byte) ’ß’;
System.out.println( (char) b );    // Ausgabe ist  ?

Das Dilemma ist wieder die fehlerhafte Vorzeichenanpassung. Bei der Benutzung des Bytes wird es zuerst in ein int konvertiert. Das »ß« wird dann zu –33. Im nächsten Schritt wird diese –33 dann zu einem char umgesetzt. Das ergibt 65503, was einen Unicode-Bereich trifft, der zurzeit kein Zeichen definiert. Es wird wohl auch noch etwas dauern, bis die ersten Außerirdischen uns neue Zeichensätze schenken. Gelöst wird der Fall wie oben, in dem von b nur die unteren acht Bits betrachtet werden. Das geschieht wieder durch ein Ausblenden über den Und-Operator. Damit ergibt sich korrekt:

char c = (char) (b & 0x00ff);

2.8.9 Variablen mit Xor vertauschen 

Eine besonders trickreiche Idee für das Vertauschen von Variableninhalten arbeitet mit der Xor-Funktion und benötigt keine temporäre Zwischenvariable. Die Zeilen zum Vertauschen von x und y lauten wie folgt:

int x = 12,
    y = 49;

x ^= y;  // x = x ^ y
y ^= x;  // y = y ^ x
x ^= y;  // x = x ^ y

System.out.println( x + " " + y );  // Ausgabe ist: 49 12

Der Trick funktioniert, da wir mit Xor etwas »rein- und rausrechnen« können. Zuerst rechnen wir in der ersten Zeile das y in das x. Wenn wir anschließend die Zuweisung an das y machen, dann ist das der letzte schreibende Zugriff auf y, also muss hier schon das vertauschte Ergebnis stehen. Das stimmt auch, denn expandieren wir die zweite Zeile, steht dort »y wird zugewiesen an y ^ x« und dies ist y ^ (x ^ y ). Der letzte Ausdruck verkürzt sich zu y = x, da aus der Definition der Xor-Funktion für einen Wert a hervorgeht a ^ a = 0. Die Zuweisung hätten wir zwar gleich so schreiben können, aber dann wäre der Wert von y verloren gegangen. Der steckt aber noch in x aus der ersten Zuweisung. Betrachten wir daher die letzte Zeile x ^ y. y hat den Startwert von x, doch in x steckt ein Xor-y. Daher ergibt x ^ y den Wert x ^ x ^ y, und der verkürzt sich zu y. Demnach haben wir den Inhalt der Variablen vertauscht. Im Übrigen können wir für die drei Xor-Zeilen alternativ schreiben:

y ^= x ^= y;   // Auswertung automatisch y ^= (x ^= y)
x ^= y;

Da liegt es doch nahe, die Ausdrücke weiter abzukürzen zu x ^= y ^= x ^= y. Doch leider ist das falsch (es kommt für x immer null heraus). Den motivierten Lesern bleibt dies als Denksportaufgabe.

2.8.10 Die Verschiebeoperatoren 

Unter Java gibt es drei Verschiebeoperatoren (engl. shift-operator). Sie bewegen die Bits eines Datenworts in eine Richtung. Obwohl es nur zwei Richtungen rechts und links gibt, muss noch der Fall betrachtet werden, ob das Vorzeichen beim Links-Shift beachtet wird oder nicht.

i << n

Der Operand i wird unter Berücksichtigung des Vorzeichens n-mal nach links geschoben (mit 2 multipliziert). Der rechts frei werdende Bitplatz wird mit 0 aufgefüllt. Das Vorzeichen ändert sich jedoch, sobald eine 1 von der Position MSB – 1 nach MSB geschoben wird. MSB steht hier für Most Significant Bit, also das Bit mit der höchsten Wertigkeit in der binären Darstellung. Erschreckenderweise ergibt 1 << 32 = 1 und nicht 0, wie zu erwarten wäre.

i >> n

Da es in Java nur vorzeichenbehaftete Datentypen gibt, kommt es unter Berücksichtigung des Vorzeichens beim normalen Rechts-Shift zu einer vorzeichenrichtigen Ganzzahldivision durch 2. Dabei bleibt das linke Vorzeichen-Bit unberührt. Je nachdem, ob das Vorzeichen-Bit gesetzt ist oder nicht, wird eine 1 oder eine 0 von links eingeschoben.

System.out.println( 65535 >> 8 );  // 255
System.out.println( 255 << 8);     // 65280

i >>> n

Der Operator >>> verschiebt eine Variable (Bitmuster) bitweise um n Schritte nach rechts, ohne das Vorzeichen der Variablen zu berücksichtigen (vorzeichenloser Rechts-Shift). So werden auf der linken Seite (MSB) nur Nullen eingeschoben; das Vorzeichen wird mitgeschoben. Bei einer positiven Zahl hat dies keinerlei Auswirkungen, und das Verhalten ist wie beim >>-Operator.

class ShiftRightDemo
{
  public static void main( String args[] )
  {
    int i = 64;
    int j = i >>> 1;

    System.out.println( " 64 >>> 1 = " + j );

    i = –64;
    j = i >>> 1;

    System.out.println( "-64 >>> 1 = " + j );
  }
}

Die Ausgabe ist für den negativen Operanden besonders spannend:

64 >>> 1 = 32
-64 >>> 1 = 2147483616

Ein <<<-Operator macht allerdings keinen Sinn, da beim Links-Shiften sowieso nur Nullen eingefügt werden.

Beim Shift nach links oder rechts steht vor dem binären Operator im rechten Operanden die Anzahl Bits, die verschoben werden. Bei einem int machen hier natürlich nur Werte bis 32 Sinn und für ein long Werte bis 64 Bit. Mit anderen Worten: Nur die ersten 5 beziehungsweise 6 Bit sind nötig.

byte b[] = { (byte)(v >>> 24) & 0xFF, (byte)(v >>> 16) & 0xFF,
             (byte)(v >>>  8) & 0xFF, (byte)(v       ) & 0xFF);

Division und Multiplikation mit Verschiebeoperatoren

Wird ein Wert um eine Stelle nach links geschoben, so kommt in das niedrigste Bit (das Bit ganz rechts) eine Null hinein und alle Bits schieben sich eine Stelle weiter. Das Resultat ist, dass die Zahl mit 2 multipliziert wird. Natürlich müssen wir mit einem Verlust von Informationen rechnen, wenn das höchste Bit gesetzt ist, denn dann wird es herausgeschoben, aber das Problem haben wir auch schon bei der normalen Multiplikation. Es gibt in Java keinen Operator, der die Bits rollt, der also die an einer Stelle herausfallenden wieder an der anderen Seite einfügt.

Wenn ein einmaliger Shift nach links mit 2 multipliziert, so würde eine Verschiebung um zwei Stellen nach links eine Multiplikation mit 4 bewirken. Allgemein gilt: Bei einem Shift von i nach links ergibt sich eine Multiplikation mit 2i. Wir können dies dazu nutzen, beliebige Multiplikationen durch Verschiebung nachzubilden.

10 * n == n << 3 + n << 1

Diese Umsetzung ist nicht immer einfach, und es gibt tatsächlich kein Verfahren, welches eine optimale Umsetzung liefert. Doch arbeiteten viele Prozessoren auf diese Weise intern die Multiplikation ab, und ein Compiler nutzt dies gern zur Optimierung der Laufzeit. Eine Verschiebeoperation ist bei vielen Prozessoren schneller als eine Multiplikation. Doch ist hier Obacht zu geben, denn eine lange Folge von Verschiebungen ist nicht schneller, sondern langsamer als eine direkte Multiplikation.

Neben der Addition kommt selbstverständlich auch die Subtraktion infrage. Ersetzen wir im oberen Beispiel das Plus durch ein Minus, so bekämen wir eine Multiplikation mit 6. Natürlich müssen wir auf die Überläufe der Zwischenergebnisse bei großen Zahlen achten. Diese würde es bei einer echten Multiplikation nicht geben.

Was wir am Beispiel der Verschiebung nach links gezeigt haben, funktioniert genauso mit einem Shift nach rechts. Jetzt wird bei einmaliger Verschiebung durch 2 dividiert. Das Ergebnis ist natürlich immer nur ganzzahlig, da die Verschiebeoperatoren nur auf int und long definiert sind; so ist 7 >> 2 = 3. Bei negativen Zahlen sieht das etwas anders aus, denn hier ist das Ergebnis –7 >> 2 = –4. Würden wir die die Division ganz klassisch mit / 2 realisieren ist das Ergebnis 7 / 2 = 3 und –7 / 2 = –3. Bei einer gedachten Optimierung ist auf diese Sonderheit bei negativen Zahlen zu achten.

Die Bitoperatoren in Assembler verglichen mit <<<, << und >>

Auch in Assembler gibt es zwei Gruppen von Schiebeoperatoren: die arithmetischen Schiebebefehle (SAL und SAR), die das Vorzeichen des Operanden beachten, und die logischen Schiebebefehle (SHL und SHR), die den Operanden ohne Beachtung eines etwaigen Vorzeichens schieben. Die Befehle SAL und SHL haben die gleiche Wirkung. So ist >>> der Bitoperator, in dem das Vorzeichen nicht beachtet wird, wie SHR in Assembler. Es gibt in Java auch keinen Bitoperator <<<, da – wie in Assembler – SAL = SHL gilt (<<< würde die gleiche Wirkung haben wie <<).

Bits rotieren

Java hat zwar Operatoren zum Verschieben von Bits, aber nicht zum Rotieren. Beim Rotieren werden Bits um eine bestimmte Stelle verschoben, die herausfallenden Bits kommen aber auf der anderen Seite wieder rein.

Eine Funktion ist leicht geschrieben: Der Trick dabei ist, die herausfallenden Bits vorher zu extrahieren und auf der anderen Seite wieder einzusetzen.

public static int rotateLeft( int v, int n )
{
  return (v << n) | (v >>> (32 – n));
}

public static int rotateRight( int v, int n )
{
  return (v >>> n) | (v << (32 – n));
}

Die Funktionen rotieren jeweils n Bits nach links oder rechts. Da der Datentyp int ist, ist die Verschiebung n in dem Wertebereich von 0 bis 31 sinnvoll.

2.8.11 Setzen, Löschen, Umdrehen und Testen von Bits 

Die Bitoperatoren lassen sich zusammen mit den Shift-Operatoren gut dazu verwenden, ein Bit zu setzen respektive herauszufinden, ob ein Bit gesetzt ist. Betrachten wir folgende Funktionen, die ein bestimmtes Bit setzen, abfragen, invertieren und löschen:

int setBit( int n, int pos )
{
  return n | (1 << pos);
}
int clearBit( int n, int pos )
{
  return n & ~(1 << pos);
}

int flipBit( int n, int pos )
{
  return n ^ (1 << pos);
}
boolean testBit( int n, int pos )
{
  int mask = 1 << pos;

  return (n & mask) == mask;
  // alternativ: return (n & 1<<pos) != 0;

2.8.12 Der Bedingungsoperator 

In Java gibt es ebenso wie in C(++) einen Operator, der drei Operanden benutzt. Dies ist der Bedingungsoperator, der auch Konditionaloperator, ternärer Operator beziehungsweise trinärer Operator genannt wird. Er erlaubt es, den Wert eines Ausdrucks von einer Bedingung abhängig zu machen, ohne dass dazu eine if-Anweisung verwendet werden muss. Die Operanden sind durch ? beziehungsweise : voneinander getrennt:

ConditionalOrExpression ? Expression : ConditionalExpression

Der erste Ausdruck muss vom Typ boolean sein und bestimmt, ob das Ergebnis Expression oder ConditionalExpression ist. Der Bedingungsoperator kann eingesetzt werden, wenn der zweite und dritte Operand ein numerischer Typ, boolescher Typ oder Referenztyp ist. Der Aufruf von Methoden, die demnach void zurückgeben, ist nicht gestattet.

Eine Anwendung für den trinären Operator ist oft eine Zuweisung an eine Variable:

Variable = Bedingung ? Ausdruck1 : Ausdruck2;

Der Wert der Variablen wird jetzt in Abhängigkeit von der Bedingung gesetzt. Ist sie erfüllt, dann erhält die Variable den Wert des ersten Ausdrucks, andernfalls wird der Wert des zweiten Ausdrucks zugewiesen.

max = ( a > b ) ? a : b;

if ( a > b )
  max = a;
else
  max = b;

Mit dem Rückgabewert können wir alles Mögliche machen, etwa ihn direkt ausgeben. Das wäre mit if/else nur mit temporären Variablen möglich.

System.out.println( ( a > b ) ? a : b );

Beispiele

Der Bedingungsoperator findet sich häufig in kleinen Funktionen. Dazu einige Beispiele:

static int min( int a, int b ) { return a < b ? a : b; }
static int max( int a, int b ) { return a > b ? a : b; }

x >= 0 ? x : -x

// Konvertierung in Großbuchstaben

c = (char)(Character.isLowerCase(c) ? (c-’a’+’A’ ) : c);

// Konvertierung in Kleinbuchstaben

c = (char)(Character.isUpperCase(c) ? (c-’A’+’a’ ) : c);

(char)( (n < 10) ? (’0’ + n) : (’a’ – 10 + n ) )

Einige Fallen

Die Anwendung des trinären Operators führt schnell zu schlecht lesbaren Programmen und sollte daher vorsichtig eingesetzt werden. In C(++) führt die unbeabsichtigte Mehrfachauswertung in Makros zu schwer auffindbaren Fehlern. Gut, dass uns das in Java nicht passieren kann. Durch ausreichende Klammerung muss sichergestellt werden, dass die Ausdrücke auch in der beabsichtigten Reihenfolge ausgewertet werden. Im Gegensatz zu den meisten Operatoren ist der Bedingungsoperator rechtsassoziativ. (Die Zuweisung ist ebenfalls rechtsassoziativ.) Die Anweisung

b1 ? a1 : b2 ? a2 : a3

ist demnach gleichbedeutend mit

b1 ? a1 : ( b2 ? a2 : a3 )

int sign( int n )
{
  return (n < 0) ? –1 : (n > 0) ? 1 : 0;
}

Der Bedingungsoperator ist kein lvalue

Der trinäre Operator liefert als Ergebnis einen Ausdruck zurück, der auf der rechten Seite einer Zuweisung verwendet werden kann. Da er rechts vorkommt, nennt er sich auch rvalue. Er lässt sich nicht derart auf der linken Seite einer Zuweisung einsetzen, dass er eine Variable auswählt, der ein Wert zugewiesen wird.² 

((richtung>=0) ? hoch : runter) = true;

¹   Die Idee ist nicht neu. In den Achtzigerjahren verwendete Donald E. Knuth das WEB-System zur Dokumentation von TeX. Das Programm wurde mit den Hilfsprogrammen weave und tangle in ein Pascal-Programm und eine TeX-Datei umgewandelt.

²   In C(++) kann dies durch *((Bedingung) ? &a : &b) = Ausdruck; über Pointer gelöst werden.