Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger

 << zurück
Java ist auch eine Insel von Christian Ullenboom
Programmieren für die Java 2-Plattform in der Version 5
Java ist auch eine Insel

Java ist auch eine Insel
5., akt. und erw. Auflage
1454 S., mit CD, 49,90 Euro
Galileo Computing
ISBN 3-89842-747-1
gp Kapitel 2 Sprachbeschreibung
  gp 2.1 Anweisungen und Programme
  gp 2.2 Elemente der Programmiersprache Java
    gp 2.2.1 Textkodierung durch Unicode-Zeichen
    gp 2.2.2 Literale
    gp 2.2.3 Bezeichner
    gp 2.2.4 Reservierte Schlüsselwörter
    gp 2.2.5 Token
    gp 2.2.6 Semantik
    gp 2.2.7 Kommentare
    gp 2.2.8 Funktionsaufrufe als Anweisungen
    gp 2.2.9 Die leere Anweisung
    gp 2.2.10 Der Block
  gp 2.3 Datentypen
    gp 2.3.1 Primitive Datentypen
    gp 2.3.2 Wahrheitswerte
    gp 2.3.3 Variablendeklarationen
    gp 2.3.4 Ganzzahlige Datentypen
    gp 2.3.5 Die Fließkommazahlen
    gp 2.3.6 Alphanumerische Zeichen
    gp 2.3.7 Die Typanpassung (das Casting)
    gp 2.3.8 Lokale Variablen, Blöcke und Sichtbarkeit
    gp 2.3.9 Initialisierung von lokalen Variablen
  gp 2.4 Ausdrücke, Operanden und Operatoren
    gp 2.4.1 Zuweisungsoperator
    gp 2.4.2 Verbundoperatoren
    gp 2.4.3 Präfix- oder Postfix-Inkrement und -Dekrement
    gp 2.4.4 Unäres Minus und Plus
    gp 2.4.5 Arithmetische Operatoren
    gp 2.4.6 Die relationalen Operatoren
    gp 2.4.7 Logische Operatoren
    gp 2.4.8 Rang der Operatoren in der Auswertungsreihenfolge
    gp 2.4.9 Überladenes Plus für Strings
    gp 2.4.10 Was C(++)-Programmierer vermissen könnten
  gp 2.5 Bedingte Anweisungen oder Fallunterscheidungen
    gp 2.5.1 Die if-Anweisung
    gp 2.5.2 Die Alternative wählen mit einer if/else-Anweisung
    gp 2.5.3 Die switch-Anweisung bietet die Alternative
  gp 2.6 Schleifen
    gp 2.6.1 Die while-Schleife
    gp 2.6.2 Schleifenbedingungen und Vergleiche mit ==
    gp 2.6.3 Die do/while-Schleife
    gp 2.6.4 Die for-Schleife
    gp 2.6.5 Ausbruch planen mit break und Wiedereinstieg mit continue
    gp 2.6.6 break und continue mit Sprungmarken
  gp 2.7 Methoden einer Klasse
    gp 2.7.1 Bestandteil einer Funktion
    gp 2.7.2 Aufruf einer Methode
    gp 2.7.3 Methoden ohne Parameter
    gp 2.7.4 Statische Funktionen (Klassenmethoden)
    gp 2.7.5 Parameter, Argument und Wertübergabe
    gp 2.7.6 Methoden vorzeitig mit return beenden
    gp 2.7.7 Nicht erreichbarer Quellcode bei Funktionen
    gp 2.7.8 Rückgabewerte
    gp 2.7.9 Methoden überladen
    gp 2.7.10 Vorgegebener Wert für nicht aufgeführte Argumente
    gp 2.7.11 Finale lokale Variablen
    gp 2.7.12 Rekursive Funktionen
    gp 2.7.13 Die Ackermann-Funktion
    gp 2.7.14 Die Türme von Hanoi
  gp 2.8 Weitere Operatoren
    gp 2.8.1 Bitoperationen
    gp 2.8.2 Vorzeichenlose Zahlen in ein Integer und Char konvertieren
    gp 2.8.3 Variablen mit Xor vertauschen
    gp 2.8.4 Die Verschiebeoperatoren
    gp 2.8.5 Ein Bit setzen, löschen, umdrehen und testen
    gp 2.8.6 Der Bedingungsoperator
  gp 2.9 Einfache Benutzereingaben


Galileo Computing

2.8 Weitere Operatoredowntop

Die bisher angesprochen arithmetischen und relationalen Operatoren finden sich in nahezu jedem Programm. Seltener sind schon Operatoren, die auf Bitebene operieren. Sie sollen im folgenden vorgestellt werden.


Galileo Computing

2.8.1 Bitoperationedowntop

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


Tabelle 2.9   Bitoperatoren in Java

Operator Bezeichnung Funktion
~ Komplement Jedes Bit wird invertiert.
| bitweises Oder Bei a | b wird jedes Bit von a und b einzeln Oder-verknüpft.
& bitweises Und Bei a & b wird jedes Bit von a und b einzeln Und-verknüpft.
^ bitweises exklusives Oder (Xor) Bei a ^ b wird jedes Bit von a und b einzeln Xor–verknüpft. (Es ist kein a hoch b!)

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:


Tabelle 2.10   Bitoperatoren in einer Wahrheitstafel

Bit 1 Bit 2 ~Bit 1 Bit 1 & Bit 2 Bit 1 | Bit 2 Bit 1 ^ Bit 2
0 0 1 0 0 0
0 1 1 0 1 1
1 0 0 0 1 1
1 1 0 1 1 0


Galileo Computing

2.8.2 Vorzeichenlose Zahlen in ein Integer und Char konvertieren  downtop

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 );    // dezimal 100, binär: 1100100
System.out.println( b2 );    // dezimal –56, binär: 1001000

Beim zweiten Byte ist eine Typanpassung nötig, da 200 den Zahlenbereich eines Byte von –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 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 Bit ausgenommen – die unteren acht heraus. Das reicht schon. Die Lösung zeigt die Funktion byteToInt():

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

Eine explizite Typanpassung mit (int) b ist nicht nötig, da die implizite Anpassung 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 Byte 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, indem von b nur die unteren acht Bit betrachtet werden. Das geschieht wieder durch ein Ausblenden über den Und-Operator. Damit ergibt sich korrekt:

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

Galileo Computing

2.8.3 Variablen mit Xor vertauschedowntop

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.


Galileo Computing

2.8.4 Die Verschiebeoperatoren  downtop

Unter Java gibt es drei Verschiebeoperatoren (engl. shift-operator). Sie bewegen die Bit 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 Bit-Platz 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.


Hinweis   Ein herausgeschobenes Bit ist für immer verloren!
System.out.println( 65535 >> 8 );  // 255
System.out.println( 255 << 8);     // 65280
Es ist 65535 = 0xFFFF und nach der Rechtsverschiebung 65535 >> 8 ergibt sich 0x00FF = 255. Schieben wir nun wieder nach links, also 0x00FF << 8, dann ist das Ergebnis 0xFF00 = 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.


Beispiel   Verschiebung einer positiven und negativen Zahl

Listing 2.11   ShiftRightDemo.java

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 ergibt allerdings keinen Sinn, da beim Links-Shiften ohnehin nur Nullen eingefügt werden.

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


Beispiel   Mit den Verschiebe-Operatoren ist es auch möglich, die einzelnen Byte eines größeren Datentyps zu extrahieren. Sollen die 4 Byte einer int-Variablen v in ein byte-Feld übertragen werden, so schreiben wir:
byte[] b = { (byte)(v >>> 24), (byte)(v >>> 16),
             (byte)(v >>>  8), (byte)(v       ) };

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 und alle Bit verschieben sich um eine Stelle weiter. Das Resultat: die Zahl wird mit 2 multipliziert. 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 Bit rollt, der also die an einer Stelle herausfallenden an der anderen Seite wieder 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.


Beispiel   Multiplikation mit 10 durch Verschiebung der Bit
10 * n == n << 3 + n << 1
Das funktioniert, da 10*n = (8+2)*n = 8*n + 2*n gilt.

Diese Umsetzung ist nicht immer einfach, und es gibt tatsächlich kein Verfahren, das 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 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 Bit rotieren

Java hat zwar Operatoren zum Verschieben der Bit, aber nicht zum Rotieren. Beim Rotieren werden einige Bit um eine bestimmte Stelle verschoben, doch die herausfallenden Bit kommen auf der anderen Seite wieder hinein.

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

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

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


Galileo Computing

2.8.5 Ein Bit setzen, löschen, umdrehen und testen  downtop

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:


Beispiel   Anwendung aller Bitoperatoren
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;
}


Galileo Computing

2.8.6 Der Bedingungsoperatotoptop

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.


Beispiel   So etwa für ein Maximum:
max = ( a > b ) ? a : b;

Dies entspricht beim herkömmlichen Einsatz für if/else:

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:


Beispiele   Das Maximum oder Minimum zweier Zahlen liefern die Ausdrücke a < b ? a : b beziehungsweise a > b ? a : b. Den Absolutwert einer Zahl liefert x >= 0 ? x : -x Ein Ausdruck soll eine Zahl n, die zwischen 0 und 15 liegt, zur Hexadezimalzahl konvertieren:
(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.)

Der Ausdruck

b1 ? a1 : b2 ? a2 : a3

ist demnach gleichbedeutend mit

b1 ? a1 : ( b2 ? a2 : a3 )

Beispiel   Wollen wir eine Funktion schreiben, die für eine Zahl n abhängig vom Vorzeichen –1, 0 oder 1 liefert, lösen wir das Problem mit einem geschachtelten trinären Operator.
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.


Beispiel   Die folgende Anwendung des trinären Operators ist in Java nicht möglich:
((richtung>=0) ? hoch : runter) = true;




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

 << zurück




Copyright © Galileo Press GmbH 2005
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de