2 Einführung in die Program- miersprache Java

(1)

Praktische Informatik I

2. Einführung in Java 2-1

2 Einführung in die Program- miersprache Java

2.1 Was ist Java?

2.2 Erste Beispiele, lexikalische Konventionen 2.3 Typen und Werte

2.4 Konstanten und Variable

2.5 Typumwandlung und Ausdrücke 2.6 Anweisungen

2.7 Felder

(2)

2.1 Was ist Java?

Java ist

• einfach zu lernen

• objektorientiert

• maschinenunabhängig

• eine der dominierenden und zukunftsträchtigen Spra- chen in der Industrie (wie C, C++)

• mit reichhaltigen Klassenbibliotheken ausgestattet (z.

B. AWT; über 20 Pakete mit über 500 Klassen)

• für moderne Programmiertechniken ausgelegt wie

• Parallelverarbeitung mit Threads

• Komponenten mit Beans

• verteiltes Rechnen mit RMI

• Multimedia-Programmierung mit dem Java Media Framework

(3)

Objektorientierung*

Moderne Programmiersprachen sind gegenwärtig meist objektorientiert. Beispiele hierfür sind C++, Smalltalk, Eiffel und Delphi. Java kann hierbei als Weiterentwick- lung von C++ verstanden werden.

„Objektorientierte Programmierung ist eine Implementie- rungsmethode, bei der Programme als kooperierende Ansammlungen von Objekten angeordnet sind. Jedes dieser Objekte stellt eine Instanz einer Klasse dar, und alle Klassen sind Elemente einer Klassenhierarchie, die durch Vererbungsbeziehungen gekennzeichnet ist.“

(Booch 1994).

* einige Texte zu diesem Kapitel sind dem Buch von Stephan Fischer und Abdulmotaleb El Saddik: Open Java, Springer-Verlag, 1999 entnommen.

(4)

Objekt und Klasse

Der Grundbegriff der Objektorientierung ist das Objekt.

Ein Objekt ist ein abgeschlossenes Element eines Pro- gramms, das darauf ausgelegt ist, bestimmte Aufgaben zu erfüllen. Ein Objekt hat eine eindeutige Identität, die es von allen anderen Objekten unterscheidet, und ein bestimmtes Verhalten, das vom Zustand des Objekts abhängen kann.

Objekte mit gleichem Verhalten werden in Klassen gruppiert. Eine Klasse beschreibt also das Verhalten und die Struktur von Objekten. Klassen werden dazu verwendet, Objekte (Instanzen) zu erzeugen (diese zu instantiieren). Klassen werden in Java durch das

Schlüsselwort class beschrieben.

(5)

Attribute und Verhaltensweisen

Im Allgemeinen besteht jede Klasse aus zwei Kompo- nenten: Attributen und Verhaltensweisen, die durch Methoden definiert werden.

Attribute, die durch Variablen definiert werden, legen die Erscheinung, den Zustand und andere Merkmale der Klasse fest. Das Verhalten einer Klasse wird durch

Methoden definiert.

Objekte kommunizieren miteinander, indem sie Nach- richten an andere Objekte senden. Empfängt ein Objekt eine Nachricht, so führt es daraufhin eine entsprechen- de Methode aus, die angibt, wie auf das Empfangen der Nachricht reagiert werden soll. Das Senden von Nach- richten kann mit dem Funktions- oder Prozeduraufruf in prozeduralen Programmiersprachen verglichen werden.

(6)

Vererbung

Vererbung ist ein Mechanismus, der es einer Klasse ermöglicht, ihre gesamten Eigenschaften von einer anderen Klasse zu erben. Vererbung wird in der OOP benutzt, um zwei Konzepte zu beschreiben, die häufig zu- sammen verwendet werden: die Spezialisierung von Klassenschnittstellen und den Import von Implementie- rungen.

Spezialisierung dient dazu, ein System von Klassen nach einer Teilmengenbeziehung zu strukturieren. Ei- nen Klasse A ist dann eine Spezialisierung einer ande- ren Klasse B, wenn alle Objekte von A die von B defi- nierte Schnittstelle ebenfalls erfüllen, A also die Schnitt- stelle von B erweitert (extends). Zu beachten ist, dass einen Klasse mit erweiterter Schnittstelle eine Unter- menge von Objekten beschreibt, da die erweiterte Be- schreibung spezieller ist.

Import beschreibt hingegen die Wiederverwendung exi- stierender Implementierungen (oder Teile davon). Wenn eine Klasse A eine Klasse B erweitert, so kann sich dies also nicht nur auf deren Schnittstelle beziehen, sondern auch auf deren Implementierung, in der weitere Funk- tionen hinzugefügt oder vorhandene an den neuen Kontext angepasst werden können.

(7)

Polymorphie

Der Begriff Polymorphie (griech: Vielgestaltigkeit) be- sagt, dass eine Variable eines bestimmten Typs in die eines abgeleiteten Untertyps umgewandelt werden

kann. Eine Variable vom (allgemeineren) Typ Fahrzeug könnte beispielsweise in den (spezielleren) Typ Auto umgewandelt werden, da sie dadurch lediglich um einige Eigenschaften erweitert wird (Konzept der Verer- bung). Objektorientierte Programmiersprachen unter- stützen in der Regel das Konzept der Polymorphie.

(8)

Dynamisches Binden

Die durch die Polymorphie eingeführten Möglichkeiten der Wiederverwendung und Erweiterbarkeit werden erst dann richtig ausgenutzt, wenn das Binden der Methoden einer Klasse an die eintreffenden Nachrichten dyna-

misch zur Laufzeit erfolgt – im Unterschied zum stati- schen Binden, das schon zur Übersetzungszeit des Programms vorgenommen wird. Man spricht auch von Late Linking, da die Komponente nicht in das aufrufen- de Programm eingebunden, sondern nur benutzt wird.

Dieses Konzept ist für ein erweiterbares System sehr nützlich, führt allerdings oft auch zu Performance-Ein- bußen.

(9)

Abschließende Bemerkung

Wir werden uns in dieser einführenden Vorlesung im Wesentlichen auf den imperativen Kern der Sprache Java beschränken. Im Hauptstudium gibt es eine wei- terführende Vorlesung über die objektorientierte Pro- grammierung, die ebenfalls die Sprache Java verwendet. Hier werden die weiterführenden Konzepte und die wichtigsten Klassenbibliotheken von Java ausführlich vorgestellt.

(10)

2.2 Erste Beispiele, lexikalische Kon- ventionen

Wir beginnen mit einigen Beispielen, um den Umgang mit dem Computer und dem Interpreter zu erlernen.

In der Quelldatei steht das Java-Programm, das der Programmierer erstellt hat (der „source code“).

Der Java-Compiler übersetzt das Quellprogramm in Bytecode und legt diesen in der Klassendatei ab.

In der Klassendatei steht der Bytecode, eine maschi- nenunabhängige, ausführungsnahe Repräsentation des Programms.

Der Java-Interpreter führt den Bytecode aus (interpre- tiert ihn).

(11)

2.2.1 Ein kleines Beispiel: Die Klasse Zaehler

(Stören Sie sich nicht daran, wenn Sie dieses Beispiel einstweilen noch nicht ganz verstehen!)

// Zaehler.java class Zaehler {

private int wert;

int wert() { return wert; } void wert(int i) { wert = i; } void inkrementiere() { ++wert; } void dekrementiere() { --wert; } }

(12)

Die Klasse ZaehlerTest

Dient zum Testen der Klasse Zaehler.

// ZaehlerTest.java import java.io.*;

class ZaehlerTest {

public static void main(String[] args) { Zaehler z = new Zaehler();

BufferedReader in =

new BufferedReader(new

InputStreamReader(System.in));

PrintWriter out = new PrintWriter(System.out, true);

for (;;) {

out.println("--- \nZählerstand: "

+ z.wert() + "\n---");

char akt = '+';

do {

out.print("Aktion (+/-): ");

out.flush();

try {

akt = in.readLine().charAt(0);

} catch (IOException ioe) { } } while (akt != '+' && akt != '-');

if (akt == '+')

z.inkrementiere();

else

z.dekrementiere();

} } }

(13)

Ausführen des Programms ZaehlerTest

Wenn wir den Java-Interpreter starten, beginnt die

Ausführung per Konvention immer mit der Klasse main. Wir sehen beispielsweise:

--- Zählerstand: 0

--- Aktion (+/-): +

--- Aktion (+/-): -

--- Aktion (+/-):

Da wir keine spezielle Eingabe als Ende – Bedingung vorgesehen haben, brechen wir das Programm mit CTRL-C ab.

(14)

Eine einfache Benutzeroberfläche

Im Java Development Toolkit (JDK) von SunSoft gibt es eine Vielzahl von Klassen, die eine einfache, maschi- nenunabhängige Programmierung von grafischen Be- nutzeroberflächen ermöglichen, Wenn man den Ab- stract Window Toolkit (AWT) importiert, stehen diese Klassen zum Aufruf zur Verfügung.

Wir schreiben nun eine neue Klasse ZaehlerFrame mit einer grafischen Oberfläche, die die zeilenorientierte Klasse ZaehlerTest ersetzt.

(15)

Beispiel: ZaehlerFrame (1)

// ZaehlerFrame.java import java.awt.*;

import java.awt.event.*;

class ZaehlerFrame extends Frame { private Button plus, minus;

private TextField stand;

private Zaehler z;

ZaehlerFrame(String s) { super(s);

z = new Zaehler();

setLayout(new GridLayout(2, 2));

add(new Label("Zählerstand: ", Label.RIGHT));

add(stand = new TextField(10));

stand.setText(String.valueOf(z.wert()));

stand.setEditable(false);

add(plus = new Button("Inkrementiere"));

add(minus = new Button("Dekrementiere"));

ButtonListener lis = new ButtonListener();

plus.addActionListener(lis);

minus.addActionListener(lis);

pack();

setVisible(true);

}

(16)

Beispiel: ZaehlerFrame (2)

public static void main(String[] args) { new ZaehlerFrame("Zähler-Test");

}

class ButtonListener implements ActionListener { public void actionPerformed(ActionEvent e) {

if (e.getActionCommand().equals("Inkrementiere")) z.inkrementiere();

else

z.dekrementiere();

stand.setText(String.valueOf(z.wert()));

} } }

(17)

Beispiel: ZaehlerApplet

Ein Applet ist ein Java-Programm, das nicht eigenstän- dig, sondern nur von einem Web-Browser aus ausge- führt werden kann. Der Browser lädt den Bytecode dynamisch vom Server und bringt ihn zur Ausführung.

// ZaehlerApplet.java import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class ZaehlerApplet extends Applet { private Button plus, minus;

private TextField stand;

private Zaehler z;

public void init() { z = new Zaehler();

setLayout(new GridLayout(2, 2));

...Rest wie ZaehlerFrame }

class ButtonListener implements ActionListener { ....wie in ZaehlerFrame

} }

(18)

Einbettung des ZaehlerApplets in eine html-Seite

<h1>Das Zähler-Applet</h1>

<hr>

<center>

<applet code = ZaehlerApplet width = 250 height = 70>

</applet>

</center>

<p>

Hier steht der <a href= “ZaehlerApplet.java“>Java- Code.</a>

(19)

2.2.2 Syntax und Semantik einer Sprache

Zur maschinellen Verarbeitung eines Algorithmus muss dieser in einer wohldefinierten Sprache (frei von Mehr- deutigkeiten und Ungenauigkeiten) ausgedrückt werden.

Eine solche Sprache heisst Programmiersprache.

Zur Ausführung eines Programms, das in einer Pro- grammiersprache vorliegt, muß der Computer in der La- ge sein,

1 die Symbole, in denen jeder Algorithmus-Schritt ausgedrückt ist, zu verstehen (Syntax),

2 dem Algorithmus-Schritt in Form von auszuführen- den Maschineninstruktionen eine Bedeutung zuord- nen (Semantik),

3 die entsprechenden Operationen auszuführen.

(20)

Syntax-Diagramme

Motivation

Eine formal definierte Syntax stellt eindeutig klar, welche Ausdrücke einer Sprache gültig sind und welche nicht.

Wir führen dazu Syntax-Diagramme ein. Sie sind bestehen aus

• Terminalsymbolen (Kreisen),

• Nichtterminalsymbolen (Quadraten) und

• gerichteten Kanten (Pfeilen), die zulässige Wege durch das Diagramm darstellen.

Wir können den gesamten Sprachumfang unserer Pro- grammiersprache durch solche Syntax-Diagramme defi- nieren. Ein gültiger Ausdruck liegt dann und nur dann vor, wenn er durch einen Pfad durch die Diagramme generiert werden kann.

(21)

Beispiel für ein Syntax-Diagramm

Digit . 1

Digit

2 Digit

.

Digit 3

e E

+ -

f F

d D Digit

2

3 1

FloatingPointLiteral

(22)

Unicode

Java-Übersetzungseinheiten werden im Unicode ge- schrieben. Dies ist ein Zwei-Byte-Code, mit dem man viele länderspezifische Zeichen, z.B. deutsche Umlaute, französische Akzente oder griechische Buchstaben darstellen kann. Die aktuelle Norm findet man in: The Uni- code Standard, Version 2.0, The Unicode Consortium, Addison-Wesley, 1996). Da es derzeit nur wenige Da- teisysteme, Editoren usw. gibt, die Unicode verarbeiten, sind „Unicode-Escapes“ definiert, mit denen man Uni- code-Zeichen im ASCII-Code darstellen kann.

HexDigit (hexadezimale Ziffer):

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B; C, D, E, F (Zahlensystem zur Basis 16)

source character : a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z

(23)

Unicode-Beispiele

• \u7933 korrekt

• \uFFA3 korrekt

• \uuuuu3059 korrekt

• \uuuuuuuuuuu0000 korrekt

• \uu89232 zu viele Hex-Ziffern

• \7230 u fehlt

• \u89W3 W ist keine Hex-Ziffer

(24)

Syntaktische Basiselemente (Token)

Die kleinsten Einheiten, aus denen sich eine Java- Übersetzungseinheit zusammensetzt, nennt man lexi- kalische Elemente oder Token. In Java gibt es sieben Kategorien von Token:

• White-Space,

• Kommentar,

• Bezeichner (identifier),

• Schlüsselwort (keyword),

• Literal,

• Interpunktionszeichen (separator) und

• Operator.

Syntax-Diagramm

White-Space Comment

Identifier Keyword Literal Separator

Operator

TokenStream

(25)

Eindeutige Zerlegung des Quellcodes in Token

Bei der Analyse einer Übersetzungseinheit werden vom Compiler immer die größtmöglichen lexikalischen Ele- mente (Token) gebildet: Wenn ein kürzeres Token in einem längeren enthalten ist, wird das längere ausgewertet.

Beispiel

++wert in der Klasse Zaehler wird ausgewertet als In- krement-Operator, gefolgt von einem Bezeichner (“identifier“), und nicht als zwei positive Vorzeichen vor einem Bezeichner.

(26)

White Space

Ein “white space“ dient zur Separation von Token. Er ist insofern semantisch wichtig und darf nicht weggelassen werden. So bedeutet zum Beispiel “+ +wert“ etwas anderes als „++wert“. Mehrere “white spaces“ hinter- einander haben dieselbe Bedeutung wie ein einzelner

“white space“.

Wir verwenden “white spaces“, um unsere Programme lesbarer zu machen.

Syntax-Diagramm

(27)

Kommentar (1)

Es gibt drei Arten von Kommentaren:

Die traditionellen Kommentare sind in /* und */ einge- schlossen.

Zeilenkommentare beginnen mit // und erstrecken sich bis zum Ende der Zeile.

Dokumentationskommentare sind in /** und */ einge- schlossen.

Es gilt:

• Kommentare können nicht geschachtelt werden.

• /* und */ haben keine besondere Bedeutung in Zeilen- kommentaren.

• // hat keine besondere Bedeutung in Kommentaren, die mit /** oder /* beginnen.

Dokumentationskommentare werden wirksam, wenn man die entsprechende Java-Datei mit dem JDK ent- haltenen Programm javadoc verarbeitet. Wenn wir ein- fach javadoc eingeben, erhalten wir die Aufrufoptionen.

javadoc legt eine HTML-Datei an, die zu Dokumentati- onszwecken zusammen mit den class-Dateien ausge- liefert werden kann.

(28)

Kommentar (2)

Syntax-Diagramm (ohne Dokumentationskomm.)

(29)

Bezeichner (identifier) (1)

Bezeichner sind Namen, die wir für die von uns dekla- rierten Klassen, Methoden, Variablen, Interfaces und Pakete wählen. Java-Bezeichner bestehen aus beliebig langen Folgen von Unicode-Buchstaben und -Ziffern.

Sie müssen mit einem Buchstaben beginnen. “A-Z“,

“a-z“, “_“ und “$“ sind Unicode-Buchstaben, “0-9“

sind Unicode-Ziffern.

Die Java-Schlüsselwörter sowie die Literale true, false und null sind nicht als Bezeichner einsetzbar.

In ASCII-basierten Systemen können die “Unicode- Escapes“ \u0000-\uffff verwendet werden.

In unserer ersten Übersetzungseinheit Zaehler.java haben wir die Bezeichner Zaehler, wert, i, in- krementiere und dekrementiere benutzt.

(30)

Bezeichner (2)

Syntax-Diagramm

Art des Bezeichners Name

class Button, BufferedReader

interface Runnable, DataInput

method start(), getAbsolutePath() variable offset, anotherString

(31)

Beispiele für Bezeichner

HowToProgramJava korrekt

_HowToProgramJava korrekt How_To_Program_Java korrekt

$How$To$Program$Java korrekt How2ProgramJava korrekt

2ProgramJava falsch: Zahl am Anfang

$$$$$$$______ korrekt

$3473109743 korrekt

\u4839 korrekt (Unicode-

Bezeichner)

(32)

Schlüsselwörter

Die folgende Tabelle enthält die Java-Schlüsselwörter.

Diese sind nicht als Bezeichner einsetzbar.

abstract boolean break byte case

catch char class const continue

default do double else extends

final finally float for goto

if implements import instanceof int

interface long native new package

private protected public return short static super switch synchronized this

throw throws transient try void

volatile while

Neben den Schlüsselwörtern sind auch die speziellen Literale true, false und null nicht als Bezeichner einsetzbar.

(33)

Literal

In einer Programmiersprache bezeichnen man als Lite- ral das, was man in mathematischen Formeln als Kon- stante bezeichnet, also Zahlen, Boolesche Werte und Buchstabenketten, die während der Ausführungszeit des Programms ihren Wert nicht ändern können.

Syntax-Diagramm

(34)

Ganzzahl (integer) (1)

Ganzzahlen (integers) entsprechen den ganzen Zahlen aus der Mathematik.

Syntax-Diagramm

Ganzzahlen sind im Normalfall int, nicht long, es sei denn, sie enden mit l (kleinem L) oder L. Eine führende 0 besagt, daß entweder eine Oktalzahl oder eine Hexa- dezimalzahl folgt.

(35)

Ganzzahl (2)

Es gibt Ganzzahlen verschiedener Größe, wie folgt:

Type Speicherbedarf Bereich

byte 8-bit, Vorzeichen, 2er-Kom- plement

-128 to 127 short 16-bit, Vorzeichen, 2er-

Komplement

-32768 to 32767 int 32-bit, Vorzeichen, 2er-

Komplement

-2**31 to 2**31-1 long 64-bit, Vorzeichen, 2er-

Komplement

-2**63 to 2**63-1 char 16-bit, kein Vorzeichen, Uni-

code

\u0000 to \uFFFF

(36)

Beispiele für Ganzzahlen

• 76438748 korrekt

• 876387432L korrekt

• 843275829l korrekt

• 198439ll zwei l, falsch

• 98432750209 (Zahl zu groß)

• 8437658lU U falsch

• 984357A439875 A falsch

• 439827O4379832 O falsch

(37)

Gleitkommazahl (floating point number)

Type Speicherbedarf Bereich

float 32-bit, IEEE 754 6-7 signifikante Dezimale double 64-bit, IEEE 754 15 signifikante Dezimale

Syntax-Diagramm

Digit . 1

Digit

2 Digit

.

Digit 3

e E

+ -

f F

d D Digit

2

3 1

FloatingPointLiteral

(38)

Beispiele für Gleitkommazahlen

32876.34857 korrekt

.43573495 korrekt

984375e-43 korrekt

439857E+93 korrekt

84e8 korrekt

439578f korrekt

349857943D korrekt

49e-45.3847 Dezimalpunkt an falscher Positi- on

.e12 nach dem Dezimalpunkt muss

mindestens eine Ziffer folgen

23.e7 korrekt

(39)

Literale für Wahrheitswerte (boolean)

Syntax-Diagramm

(40)

Buchstaben-Literal (character literal)

Buchstaben-Literale werden in Apostrophe eingeschlos- sen. Mit Escape-Sequenzen stellt man Buchstaben- Literale dar, die nicht als druckbare ASCII-Zeichen aufgeschrieben werden können sind.

Syntax-Diagramm

(41)

Escape-Sequenzen

Gebräuchliche Escape-Sequenzen sind:

Escape- Sequenz

Unicode- Äquivalent

Bedeutung

\b \u0008 Backspace

\t \u0009 Horizontal tab

\n \u000a Linefeed

\f \u000c Form feed

\r \u000d Carriage return

\" \u0022 Double quote

\' \u0027 Single quote

\\ \u005c Backslash

\xxx \u0000 to \u00ff Character correspon- ding to the octal value

(42)

Buchstabenfolge (string)

Syntax-Diagramm

(43)

Interpunktionszeichen

Die folgenden neun Zeichen dienen in Java als Inter- punktionszeichen:

( ) { } [ ] ; , Syntax-Diagramm

(44)

Operatoren

Operatoren führen Operationen auf ihren Operanden (Argumenten) aus. In Java sind die folgenden Operato- ren definiert:

NonAssignmentOperator

+ - ++ --

% * /

>> >>>

(mit und ohne sign-extension)

<<

~ | & ^

&& || !

!= ==

< >=

> <=

? :

AssignmentOperator

= -= *=

/= |= &=

^= += %=

>>= >>>= (mit und ohne sign-extension)

<<=

(45)

Additive und multiplikative Operatoren

Operator Bedeutung algebraisch Java

+ Addition f+7 f+7

- Subtraktion p-c p-c

* Multiplikation bm b*m

/ Division x/y x/y

% modulo r mod s r % s

(46)

Operatoren zum Inkrementieren und Dekremen- tieren

++ Inkrement um 1 (als prefix oder postfix) -- Dekrement um 1 (als prefix oder posfix)

Beispiele

a = 7; // a wird 7 zugewiesen

a++; // a wird auf 8 inkrementiert, wie a = a + 1;

// inkrementiert nach der Auswertung der Variablen!

a--; // a ist wieder 7, wie a = a - 1;

++a; // a ist wieder 8, wie a = a + 1;

// VORSICHT: inkrementiert vor der Aus- wertung der Variablen!

Bemerkung

Inkrement- und Dekrement-Operatoren können Code schwer lesbar machen. Am besten nur als Einzelanwei- sung benutzen, nicht in Ausdrücken.

(47)

Logische Operatoren

&& logisches UND

|| logisches ODER

! Logisches NICHT

Beispiele

a && b a AND b a UND b

a || b a OR b a ODER b

!a NOT a NICHT a

(48)

Zuweisungsoperatoren

= zuweisen a = 2;

+= zuweisen und addieren a +=2; a = a + 2;

-= zuweisen und subtrahieren a -= 2; a = a - 2;

*= zuweisen und multiplizieren a *= 2; a = a * 2;

/= zuweisen und dividieren a /= 2; a = a / 2;

%= zuweisen und modulo a %= 2; a = a % 2;

…

Bemerkung

Man benutze die kombinierten Zuweisungsoperatoren mit Vorsicht! Sie können den Code schwer lesbar machen.

(49)

Vergleichsoperatoren (relationale Operatoren)

Die Vergleichsoperatoren haben zwei Operanden. Ihre Auswertung ergibt einen Wahrheitswert (Booleschen Wert).

Java Beispiel Bedeutung

== x == y x ist gleich y

!= x != y x ist ungleich y

> x > y x ist größer als y

< x < y x ist kleiner als y

>= x >= y x ist größer oder gleich y

<= x <= y x ist kleiner oder gleich y

(50)

2.3 Typen und Werte

Jedem von uns deklarierten Bezeichner muß genau ein Typ zugeordnet sein, der festlegt, welche Operationen für den Bezeichner definiert sind, wieviel Speicherplatz zu reservieren ist und welche Werte dem jeweiligen Speicherinhalt entsprechen. Mit jedem Typ ist auch ein Wertebereich, das ist die Menge der Werte, die eine Variable dieses Typs annehmen kann, festgelegt.

Java ist eine Sprache mit strenger Typprüfung. Jede Variable und jeder Ausdruck hat einen Typ, der beim Übersetzten bekannt ist. Zusätzlich werden von uns vorgenommene Typkonversionen statisch (beim Über- setzen) und, sofern dies erst zur Laufzeit möglich ist, dynamisch geprüft.

(51)

Datentypen

In Java werden zwei grundlegende Typen unterschie- den: Elementare Typen und Referenztypen.

• Die elementaren Typen bestehen aus dem logischen Typ boolean und den numerischen Typen.

Numerische Typen sind die ganzzahligen Typen byte, short, int, long und char sowie die Gleitpunkttypen float und double.

• Referenztypen sind Klassen, Interfaces und Felder.

(52)

Klasse und Objekt als Typ und Instanz

Ein Objekt ist in Java eine Ausprägung (Instanz) einer Klasse. Man kann also eine Klasse als einen Typ auf- fassen. Für einen solchen Typ können zur Laufzeit In- stanzen (= Objekte) kreiert und wieder zerstört werden.

Alle Objekte sind implizit Instanzen der Klasse Object und verfügen damit über deren Methoden; u.a.

public String toString() { ... }

public boolean equals (Object obj) { ... } protected Object clone()

throws CloneNotSupportedException { ... } protected void finalize() throws Throwable { ... }

Mittels toSting ist es möglich, jedes Objekt in eine für das Objekt charakteristische Zeichenkette umzuwandeln (und diese z.B. auszugeben). Mit equals können wir vergleichen, ob zwei Objekte identisch sind. clone erzeugt eine Kopie eines Objekts, und finalize ist eine Methode, die aufgerufen wird, unmittelbar bevor ein Objekt wieder zerstört wird. Objekte werden grundsätz- lich erst zur Laufzeit dynamisch erzeugt. Werte eines Referenztyps sind Referenzen (Zeiger) auf Objekte.

(53)

2.4 Konstanten und Variable

Wie die meisten anderen Programmiersprachen unterscheidet Java Konstanten und Variable.

Eine Konstante erhält ihren Wert bereits zum Zeitpunkt der Niederschrift des Programms zugewiesen; dieser Wert kann sich zur Laufzeit des Programms niemals ändern. Konstante können symbolische Namen haben, zum Beispiel pi. Oder sie können unmittelbar als Wert aufgeschrieben werden, dann sind es gerade die bereits eingeführten Literale.

Eine Variable ist ein Platzhalter für einen Wert. Der aktuelle Wert kann sich zur Laufzeit des Programms (auch mehrfach) ändern.

(54)

Konstanten

Syntax für Konstante

final Typ VariablenName = Wert

oder

final Typ VariablenName;

Beispiel:

final int x = 5

Wichtig:

Konstanten sind Platzhalter für Werte, während Varia- blen Platzhalter für Adressen sind. Daher können Kon- stanten ihre Werte nicht verändern. Die Werte der Va- riablen sind dagegen vom Inhalt der Speicherzellen be- stimmt.

(55)

Oktale und hexadezimale Konstanten

In Hexadezimaldarstellung beginnt eine ganzzahlige Konstante mit 0x oder 0X und besteht aus mindestens einer weiteren Hexadezimalziffer (0-9, a-f oder A-F).

(56)

Die Nullreferenz

Die Nullreferenz, die anzeigt, daß eine Variable aktuell kein Objekt referenziert, wird durch das Literal null re- präsentiert.

(57)

Variable

Variable sind Platzhalter für Werte. Sie sind können auch als Namen für Speicheradressen aufgefasst werden, denen ein fester Typ zugewiesen ist.

Kontrolleinheit

Arithm. Einheit

5 4 9

nächste Inst.

add 4,3,2

ersterWert

zweiterWert resultatWert

1 0 Hauptspeicher

ersterWert ist 5 und repräsentiert Speicheradresse 4.

zweiterWert ist 4 und repräsentiert Speicheradresse 3.

resultatWert ist 9 und repräsentiert Speicheradresse 2.

(58)

Variablennamen

In den meisten Fällen sind Variablennamen Bezeichner (identifier). Als Namen für Variable können aber auch beliebig viele mit “.“ aneinander gereihte Bezeichner vorkommen, zum Beispiel

std.a y.out

employee.address.zipcode

Die genaue Bedeutung dieser Bezeichnerkombinationen wird im objektorientierten Teil von Java erläutert.

(59)

Beispiele für Variable

In unserem Beispiel ZaehlerTest haben wir sechs Va- riablen deklariert: args, z, in, out und ioe sind Variablen eines Referenztyps. Genauer ist args Varia- ble des Feldtyps Sting[], z Variable des Klassentyps Zaehler, in Variable des Klassentyps BufferedRea- der, out Variable des Klassentyps PrintWriter und ioe Variable des Klassentyps IOException. Die ver- bleibende Variable akt hat den elementaren ganzzahligen Typ char.

(60)

Deklaration von Variablen

Bevor Variable im Programm verwendet werden, müs- sen sie deklariert werden.

Typ VariablenName;

oder

Typ VariablenName = Wert;

Beispiele:

int sum = 5 double value;

Nutze Komma für Mehrfachdeklaration:

int sum1, sum2 = 5, sum6;

Typen:

char

byte, short, int, long

float, double

(61)

Initialisierung von Variablen

Unter der Initialisierung einer Variablen oder symboli- schen Konstanten versteht man das Kopieren eines Werts in ihren Speicherplatz direkt im Zusammenhang mit dessen Reservierung.

Beim Zuweisen wird dagegen ein Wert in eine ander- weitig erzeugte Variable kopiert.

An machen Variablen ist keine Zuweisung möglich:

Klassenvariablen, Instanzvariablen und lokale Varia- blen, die wir final spezifizieren, müssen wir bei ihrer De- klaration initialisieren.

Auch an Methoden- und Konstruktorparameter sowie den Parameter eines Ausnahme Handlers können wir nichts zuweisen – hier werden die Initialisierungen mit den Aufrufargumenten bzw. dem ausgeworfenen Aus- nahmeobjekt von der VM vorgenommen.

(62)

In Java verwischt sich der Unterschied zwi- schen Initialisierung und Zuweisung

Im Unterschied zu anderen Programmiersprachen, die für Initialisierung bzw. Zuweisung verschiedene Opera- toren bzw. Methoden benutzen, verfährt Java beim In- itialisieren einer Variablen genau wie bei Zuweisungen:

Wert und Typ des Initialisierers werden ermittelt, falls nötig (und zuweisungskompatibel) in den Typ der Varia- blen umgewandelt, das Resultat wird in deren Speicher- platz kopiert. In der Java-Literatur wird wegen dieser Analogie oft nicht präzise formuliert und von Zuweisun- gen gesprochen, auch wenn es sich um Initialisierungen handelt.

(63)

2.5 Typumwandlung und Ausdrücke

Da Java streng typisiert ist, kann man einer Variablen nur einen Wert vom gleichen Typ zuweisen, oder man kann mit einem Vergleichsoperator nur Ausdrücke gleichen Typs vergleichen. Gäbe es keine Typumwandlung, so wäre man in der Programmierung sehr inflexibel.

Man unterscheidet die implizite und die explizite Typ- umwandlung.

Bei Typumwandlungen kann es zu Genauigkeitsverlu- sten und zu Verlusten im darstellbaren Wertebereich (Größenverlusten) kommen.

(64)

2.5.1 Typumwandlung

Wenn in einem Ausdruck in Java zwei Typen nicht zu- einander passen, wird entweder eine

• implizierte Typumwandlung (type casting) durchgeführt oder ein

• Syntax-Fehler gemeldet.

Es ist also in Java nicht möglich, einen Speicherplatz als Bitfolge aufzufassen und im Programm mal so und mal anders zu interpretieren!

Beispiele

int i = 5

int j = 4L // impliziter Type-Cast von long zu int long k

k = i // impliziter Type-Cast von int zu long

(65)

Implizite Typumwandlung

Implizite Konversionen werden von Java in vier Situatio- nen vorgenommen, auf die später noch genauer einge- gangen wird:

• bei Zuweisungen und Initialisierungen (die Java als semantisch äquivalent betrachtet),

• bei Methoden- und Konstruktoraufrufen. Hier wird ein Argumentwert an einen Parameter übergeben.

• bei numerischen Typangleichungen im Zusammen- hang mit arithmetischen Operatoren. Hier wird ein Wert in einem umfassenderen Ausdruck ausgewertet.

• bei String-Konversionen – hier wird ein Wert durch den Operator + mit einem String-Objekt verknüpft.

(66)

Beispiel für Typumwandlungen

// KonversionsKontexte.java import java.io.*;

class KonversionsKontexte { static PrintWriter out =

new PrintWriter(System.out, true);

static void m(double d) { out.println(„m(double)“);

}

public static void main(String[] args) { long l = 5;

float x = 1.25f;

m(x);

x = x*l;

out.println(„x = „ + x);

short s = (short)x;

} }

(67)

Elementare Typvergrößerungen

Die folgenden Typumwandlungen werden als elementare Typvergrößerungen bezeichnet. Java nimmt diese Konversionen, falls nötig, bei Zuweisungen, Methoden- und Konstruktoraufrufen und bei der Auswertung von Ausdrücken implizit vor:

byte nach short, int, long, float oder double short nach int, long, float oder double

char nach int, long, float oder double int nach float oder double

long nach float oder double float nach double

Bei den Umwandlungen ganzzahliger Typen in andere ganzzahlige Typen und bei der Umwandlung von float nach double kann es zu keinerlei Informationsverlust bezüglich der konvertierten Werte kommen – die Um- wandlungen sind „sicher“.

(68)

Elementare Typverkleinerungen

Die folgenden Typumwandlungen werden als elementa- re Typverkleinerungen bezeichnet:

byte nach char

short nach byte oder char char nach byte oder short

int nach byte, short oder char

long nach byte, short, char oder int

float nach byte, short, char, int, oder long double nach byte, short, char, int, long, oder

float

Bei allen diesen Umwandlungen kann es zu Informati- onsverlusten in bezug auf Genauigkeit und Größen- ordnung kommen. Bei Konversionen von ganzzahligen im ganzzahlige Typen werden die höchstwertigen Bits entfernt; bei Konversionen von Gleitpunkttypen in ganzzahlige Typen werden die Nachkommastellen abge- schnitten.

Elementare Typverkleinerungen können nur durch ex- plizite Casts und bei Zuweisungen implizit vorge- nommen werden.

(69)

Beispiel für Typverkleinerungen

// IntByte.java import java.io.*;

class IntByte {

public static void main(String[] args) { PrintWriter out = new PrintWriter(

System.out, true);

int i = 0x7fffffff;

byte b = (byte)i;

out.println(„Wert vor Konversion: „+i + „\nWert nach Konversion: „ + b);

} }

(70)

Vergrößerung von Referenztypen

Auch bei Referenztypen sind Typvergrößerungen und – verkleinerungen möglich.

Die wichtigste vergrößernde Typumwandlung ist die von einer Klasse K zu einer Klasse L, wobei K Subklas- se von L ist. Weiterhin ist null in jeden Klassen-, Inter- face- oder Feldtyp konvertierbar; die entsprechenden Konversionen zählt ebenfalls zur Typvergrößerung. Java nimmt Vergrößerungen von Referenztypen, falls nötig, bei Zuweisungen und bei Methoden- und Konstruk- toraufrufen implizit vor.

(71)

Verkleinerung von Referenztypen

Die wichtigste verkleinernde Typumwandlung ist die von einer Klasse K zu einer Klasse L, wobei K Super- klasse von L ist.

Verkleinerungen von Referenztypen können nur durch explizite Casts vorgenommen werden. Bei diesen Kon- versionen wird zur Laufzeit geprüft, ob die aktuell zu konvertierenden Referenzen einen für den neuen Typ zulässigen Wert enthalten.

(72)

Implizite Typumwandlung nach

String String-Konversionen werden von Java mit Operanden des Operators + durchgeführt, sofern einer der Operato- ren vom Typ String ist. In diesem Fall wird der andere Operand implizit in einen String umgewandelt, und das Resultat in ein neues String-Objekt, das aus den beiden aneinandergefügten Strings besteht.

Diese Konversion haben wir bei fast allen println- Aufrufen der letzten Beispiele in Anspruch genommen.

(73)

Explizite Typumwandlung nach

String Jeder Java-Datentyp kann auch explizit in den Typ String konvertiert werden. Dazu verwendet Java bei Referenztypen die Methode toString und bei elementaren Typen die Methode valueOf aus der Klasse String.

Beispiel

public class MeinProgramm {

public static void main(String[] args) { int i=5;

Frame frame = new Frame();

System.out.println(„Zahl: „+i);

System.out.println(frame.toString());

System.out.println(String.valueOf(i));

} }

(74)

Explizite Typumwandlung: der Cast-Operator

Mit Hilfe des Cast-Operators () kann der Typ eines Ausdrucks explizit in den in Klammern angegebenen Typ umgewandelt werden:

(Zieltyp) ausdruck

Beispiel 1:

double x = 9.99;

int i = (int) x;

Beispiel 2:

g.drawString(„Hello World“,

(int) x, (int) x);

Die Verkleinerung von Referenztypen ist nur durch explizite Casts möglich; dabei kann es zu Übersetzungs- und Laufzeitfehlern kommen.

(75)

Beispiel für den Cast-Operator

public class MeinProgramm extends Frame {

static MeinProgramm meinProgramm;

public static void main(String[] args) { meinProgramm = new MeinProgramm();

Frame f = (Frame) MeinProgramm;

MeinProgramm mp = (MeinProgramm) f;

} }

(76)

2.5.2 Ausdrücke

Ausdrücke produzieren Werte, wenn sie berechnet werden. Sie bestehen aus Operatoren und Operanden. Die Operanden können Variable oder Konstanten sein.

Der Typ eines Ausdrucks hängt von den beteiligten Operatoren, den Datentypen der Operanden und den vorgenommenen Typumwandlungen ab.

Beispiele

float mittelwert = (a+b)/2;

**int k = (int) ((a+b)*i++);**

(77)

Arten von Ausdrücken

Man unterscheidet:

• Einstellige, zweistellige und dreistellige Operatoren, je nach der Anzahl der beteiligten Operanden.

• Präfix-, Infix- und Postfix-Operatoren, je nach Schreibweise: vor, zwischen oder nach den Ope- randen.

• Links- und rechts-assoziative Operatoren: Treten gleiche Operatoren in einem Ausdruck nebenein- ander auf, so wird bei links-assoziativen Operatoren von links nach rechts und bei rechts-assoziativen Operatoren von rechts nach links ausgewertet.

• Operatoren verschiedener Priorität: Treten in einem Ausdruck verschiedene Operatoren zusammen auf, so werden sie nach absteigender Priorität (abstei- gendem Vorrang) ausgewertet.

(78)

Berechnung von Ausdrücken

Jeder Ausdruck hat einen Typ, der beim Übersetzen festgestellt wird. Der Wert eines Ausdrucks ist immer zuweisungskompatibel zu seinem Typ, d.h. einer Va- riablen vom Typ T kann immer nur der Wert eines Aus- drucks vom Typ T zugewiesen werden.

Es gibt drei Grundregeln bei der Auswertung von Java- Ausdrücken:

• Ausdrücke werden von links nach rechts ausgewertet.

• Argumentlisten werden von links nach rechts ausgewertet

• Unabhängig von den Vorrangregeln für Operatoren wird ein Ausdruck in Klammern (...) ausgewertet, bevor ein Operator außerhalb der Klammern auf ihn angewendet wird.

(79)

Elementare Ausdrücke

Die einfachsten Ausdrücke sind elementare Ausdrük- ke. Zu ihnen gehören die Literalkonstanten, in (...) ge- klammerte Ausdrücke, das Schlüsselwort this, Zugriffe auf Instanzvariablen, Zugriffe auf Feldkomponenten sowie Methoden- und Konstruktoraufrufe.

Beispiele für elementare Ausdrücke aus unseren bishe- rigen Programmen sind:

"Aktion(+/-):"

1.25f (b&c)

z.wert()

new Zaehler()

(80)

Präfix- und Postfix-Ausdrücke

Präfix- und Postfix-Ausdrücke dienen zum Inkremen- tieren und Dekrementieren einer Variablen. Die Varíable muss einen numerischen Typ haben.

Präfix-Ausdruck

Zuerst wird die Variable inkrementiert bzw. dekrementiert, dann wird der Ausdruck berechnet.

Syntax-Diagramm

Postfix-Ausdruck

Zuerst wird der Ausdruck berechnet, danach wird die Variable inkrementiert bzw. dekrementiert

Syntax-Diagramm

(81)

Beispiele für Präfix- und Postfix-Ausdrücke

int g = 0;

g++;

g--;

--g;

++g;

(82)

Unäre Ausdrücke (1)

Unäre Ausdrücke beginnen mit einem einstelligen Ope- rator.

Ist der einstellige Operator ein + oder - (ein Vorzeichen), so muss der Operand einen numerischen Typ haben.

Der einstellige Operator + wird nur selten benutzt.

Ist der einstellige Operator ein ~ (bitweises Komple- ment), so muss der Operand eine Ganzzahl sein.

Ist der Operator ein ! (logisches NICHT), so muss der Operand vom Typ boolean sein.

Der Cast-Operator (...) wurde schon weiter oben behan- delt. Zu beachten ist, dass die Anwendung des Cast- Operators einen Wert liefert und nicht eine Variable. So gilt etwa:

(long)i = 5; // Fehler

(83)

Unäre Ausdrücke (2)

Syntax-Diagramm

UnaryExpression

PrimaryExpression PrefixExpression PostfixExpression

+ -

!

~

(

^Type

)

(84)

Beispiele für unäre Ausdrücke

int i = -7,

j = ~0x02BF, k = +42;

i = (int) 3.1415;

j = -i--;

j = - --i;

double d = 3.1415;

i = - (int) d;

i = -~i;

i = ~~~~~~~~~~~~~~~~~~~~i;

(85)

Primärer Ausdruck und Term

Syntax-Diagramm

Term

Expression this super

null Literal

FieldExpression MethodCallExpression

ClassLiteral

( )

(86)

Beispiele für Terme

**/* String Literal: */**

String myName =

"Prof. Dr. W. Effelsberg";

**/* Boolean Literal: */**

boolean isStaffMember = true;

**/* Klammerung: */**

int i = 5;

int j = (5);

**/* Type-Cast: */**

i = (int) 5.7;

**/* Type-Cast und Klammerung: */**

i = (int) ( .6 + 5.7 );

i = (int) .6 + 5.7; //falsch

(87)

Multiplikationsausdruck (1)

Die multiplikativen Operatoren *, / und % sind zweistellig und links-assoziativ. Die Operanden müssen jeweils numerische Typen besitzen.

Je nach Operandentyp wird dann ganzzahlige Arithmetik oder Gleitpunkt-Arithmetik benutzt; als Resultat ergibt sich ein Wert, keine Variable

Wie üblich bezeichnen * und / Multiplikation bzw. Divi- sion. Der Operator % liefert den Rest der Division des linken durch den rechten Operanden. Bei ganzzahligen Operanden wirft Division durch 0 eine Ausnahme des Typs ArithmeticException aus.

Bei ganzzahligen Operanden berechnet r = a%b den Rest der ganzzahligen Division von a durch b (d.h. die Zahl r, für die (a/b)*b + r gleich a gilt.

(88)

Multiplikationsausdruck (2)

Syntax-Diagramm

MultiplicativeExpression

(89)

Additionsausdruck (1)

Die additiven Operatoren + und – sind zweistellig und links-assoziativ. Wie üblich haben sie eine geringere Priorität als die multiplikativen Oparatoren.

Ist einer der Operanden des +-Operators vom Typ

String, so wird wie oben erläutert verfahren, und das Resultat ist vom Typ String. Anderenfalls müssen beide Operanden numerische Typen besitzen.

Das Resultat ist jeweils ein Wert, keine Variable.

Beispiele

1 + 2 + ″PC″ // Resultat: ″3 PC″

″PC″ + 1 + 2 // Resultat: ″PC12″

(90)

Additionsausdruck (2)

Syntax-Diagramm

AdditiveExpression

(91)

Beispiele für Additions- und Multiplikationsausdrücke

double a = 1.3, b = 3.1;

double arithMittel = (a+b)/2;

double geoMittel =

Math.sqrt( a*a + b*b );

Aber auch a * -b

ist ein gültiger Ausdruck!

(92)

Beispiel für Division mit Rest

System.out.println(

i + " durch " + j +

" ist " +(i/j)+". Rest: "+

(i%j));

ergibt für i = 17:

17 durch 4 ist 4. Rest 1

(93)

Shift-Ausdruck (1)

Die Shift-Operatoren <<, >> und >>> sind zweistellig und links-assoziativ. Sie verschieben jeweils den linken Operanden bitweise um eine mit dem rechten Operan- den festgelegte Shift-Distanz. Beide Operanden müs- sen ganzzahlige Typen besitzen.

<< bzw. >>> verschieben die Bits des linken Operanden um die Shift-Distanz nach links bzw. rechts und füllen rechts bzw. links mit 0-Bits auf. >> verschiebt den linken Operanden um die Shift-Distanz nach rechts und füllt links mit dem alten Wert des höchstwertigen Bits auf (sog. „Sign Extension“), so daß des ursprüngliche Vor- zeichen des linken Operanden erhalten bleibt.

(94)

Shift-Ausdruck (2)

Syntax-Diagramm

ShiftExpression

(95)

Beispiele für Shiftausdrücke (1)

System.out.println(

"Zuerst ist i = " + i);

i = i << 2;

System.out.println(

"i << 2 ergibt " + i);

i = i >> 3;

System.out.println(

"i >> 3 ergibt nun " + i);

Ergibt:

Zuerst ist i = 10 i << 2 ergibt 40 i >> 3 ergibt nun 5

(96)

Beispiele für Shiftausdrücke (2)

System.out.println(

"+10>>3 ergibt "+(+10>>3));

System.out.println(

"-10>>3 ergibt "+(-10>>3));

System.out.println(

"-10>>>3 ergibt "+(-10>>>3));

Ergibt:

+10>>3 ergibt 1 -10>>3 ergibt -2

-10>>>3 ergibt 536870910

(97)

Vergleichsausdruck (relationaler Ausdruck)

Die relationalen Operatoren <, <=, >= und in- stanceof sind zweistellig und links-assoziativ. Ein

Ausdruck mit relationalen Operatoren ist immer vom Typ boolean.

Die Operanden von < (kleiner) oder gleich), > (größer) und >= (größer oder gleich) müssen jeweils numerische Typen besitzen. Das Ergebnis hat den Wert true, wenn die spezifizierte Ungleichung zutrifft und anderenfalls false.

Ein Ausdruck wie a < b < c ist immer ein Fehler, da er in der Form (a < b) < c ausgewertet wird und a <

b vom Typ boolean, also nicht numerisch ist.

(98)

Vergleichsausdruck (2)

Syntax-Diagramm

(99)

Gleichheits-Ausdruck (1)

Die Gleichheitoperatoren == und != sind zweistellig und links-assoziativ. Ein Ausdruck mit Gleichheitsoperatoren liefert immer einen boolean-Wert.

Die Operanden von == (gleich) und != (ungleich) müs- sen

• beide numerische Typen besitzen,

• beide vom Typ boolean sein oder

• beide einen Referenztyp haben oder null sein.

(100)

Gleichheits-Ausdruck (2)

Syntax-Diagramm

(101)

Beispiele für Vergleichsausdrücke

boolean

mayDrinkAlcohol = age >= 21, mustnotDriveCar = age < 16;

char c =

identifier.firstCharacter();

if ( c>='0' && c<= '9' )

System.out.println("Error");

(102)

Beispiele für Vergleichs- und Gleichheitsausdrücke

boolean ergebnis = a == b;

if ( a != b)

System.out.println

("a ist ungleich b");

boolean tautologie = (a > b) == (b < a);

// Umständlich, aber richtig:

if ( ergebnis == true ) ...

if ( ergebnis != false ) ...

// Knapper:

if ( ergebnis ) ...

(103)

Gleichheit von Referenzvariablen

Elementare Typen und Referenztypen unterscheiden sich grundlegend bei Gleichheitsausdrücken!

Beispiel 1

int i = 5, j = 6;

i += 1;

System.out.println( i == j );

ergibt true.

Beispiel 2

String s1 = "Zwergel", s2 = "stern",

t1 = "Zwerg", t2 = "elstern";

System.out.println (s1+s2 == t1+t2);

ergibt false.

Grund: String ist ein Referenztyp.

(104)

Bitweiser Vergleichsausdruck (1)

Die Bit-Operatoren und die logischen Operatoren &

(UND),^ (Exklusiv-ODER) und I (Inklusiv-ODER) sind zweistellig und links-assoziativ. Sie haben unterschiedli- che Prioritäten; & hat die höchste, ^ hat mittlere, I hat die niedrigste Priorität.

Die Operanden müssen entweder beide ganzzahlige Typen besitzen (dann werden die Bit-Operatoren angewendet) oder beide vom Typ boolean sein (dann werden die logischen Operatoren angewendet).

Die einzelnden Bits der Operanden werden dazu wie folgt verknüpft:

Bit1 Bit2 Bit1 & Bit2 Bit1 ^ Bit2 Bit1 I Bit2 0 0

0 1 1 0 1 1

0 0 0 0 1 1 0 1 1 1 0 1

(105)

Bitweiser Vergleichsausdruck (2)

Syntax-Diagramme

(106)