der Universität Oldenburg

Präsentation zum Thema: "der Universität Oldenburg"—  Präsentation transkript:

1 der Universität Oldenburg
Programmierkurs Java Vorlesung am FB Informatik der Universität Oldenburg Vorlesung 4 Dietrich Boles

2 Gliederung von Vorlesung 4
Java-Grundlagen Java-Programme Zeichensätze Kommentare Token Schlüsselwörter Bezeichner Variablen Motivation Datentypen Initialisierung Ausdrücke Motivation Definition Operatoren Erweiterung des Hamster-Modells

3 Grundlagen / Java-Programme
Erstellen und Ausführen: (1) Eingeben eines Programms (2) Compilieren (javac) evtl. Syntaxfehler beseitigen! (3) Ausführen (java) Beispiel: (1) Datei „World.java“ : (2) javac World.java (3) java World import java.io.*; public class World { public static void main(String[] args) { try { System.out.println(„Hello world!“); } catch (Exception e) { System.out.println(„Fehler!“); } } } „to-do“-Code

4 Grundlagen / Zeichensätze
Java zugrundeliegender Zeichensatz: Unicode 16-Bit-Zeichensatz (216 Zeichen) ersten 256 Zeichen: Latin-1 ersten 128 Zeichen: ASCII (7-Bit-Zeichensatz) Escape-Sequenz \udddd als (Ersatz-)Darstellung von Unicode-Zeichen; d ist hexadezimale Ziffer (0-9 und a-f) gültiger Bezeichner: ab\u4711\u8a9fcd Bitte nur ASCII-Zeichen verwenden !!!!!!!!!!!!!

5 Grundlagen / Kommentare
Zeilenkommentar: // Kommentar Bereichskommentar: /* Kommentar */ Dokumentationskommentar: /** Kommentar */ import java.io.*; // gibt „Hello world!“ aus public class World { public static void main(String[] args) { try { /* Ausgabe- befehl */ System.out.println(„Hello world!“); } catch (Exception e) { System.out.println(„Fehler!“); } } } Keine Schachtelung möglich!

6 Grundlagen / Token Token: lexikalische Einheiten Trennung von Token:
Symbole: <, =, <=, ... Schlüsselwörter: while, if, ... Bezeichner: Prozedurnamen, Klassennamen, ... Literale: true, 23, 24.5f, „hello world“, ... Trennung von Token: Leerzeichen (Blank) Tabulator Zeilenende Zeilenvorschub Seitenvorschub „gefräßiger“ Tokenizer: Zusammenfassung möglichst vieler Zeichen

7 Grundlagen / Schlüsselwörter

8 Grundlagen / Bezeichner
Benennung von deklarierten Einheiten und Labeln: Klassennamen Variablennamen Prozedurnamen ... Beginn mit Buchstabe, Unterstrich oder Dollar anschließend: Buchstaben, Ziffern, Unterstrich, Dollar, Unicode-Zeichen Grundlage: Unicode-Zeichensatz Katze Kätzchen abcdefghassasasasassasasasas Bitte nur ASCII-Zeichen verwenden!

9 Variablen und Ausdrücke / Motivation
Der Hamster soll bis zur nächsten Wand laufen, dabei alle Körner einsammeln, die er findet, und an der Wand genauso viele Körner ablegen, wie er eingesammelt hat. Notwendige Voraussetzungen: Gedächtnis ( Speicher) Zählen/Rechnen/Vergleichen ( Operationen) Programm: *1:„gefundene Anzahl ist 0“; while (vornFrei()) { vor(); while (kornDa()) { nimm(); *2:„erhöhe gefundene Anzahl um 1“; } while ( *3:„gefundene Anzahl größer als 0 ist“ ) { gib(); *4:„erniedrige gefundene Anzahl um 1“;

10 Variablen / Definition
Notwendig für *1: Reservierung von Speicherplatz ( Variablendefinition) Festlegung eines Namens ( Variablendeklaration) Festlegung des Typs ( Datentypen) Initialisierung hier: int anzahl = 0; Variablendeklaration/-definition: Deklaration: Bekanntgabe eines Namens für den Speicherbereich an den Compiler Definition: Reservierung von Platz im Hauptspeicher Hauptspeicher Programm Daten „Gedächtnis“

11 Variablen / Definition
<Variablendefinition> ::= <Datentyp> <Bezeichner> [„=“ <Ausdruck>] {„,“ <Bezeichner> [„=“ <Ausdruck>]} „;“ int anzahl = 0; long grosse_zahl = L; float pi = F; float noch_eine; char eins = `1`, zwei = `2`, drei = `3`; char neue_zeile = `\n`; String hello = „hello world!“; boolean wahr = true; int abcdefgh = 4711;

12 Variablen / Datentypen
Daten haben unterschiedliche Eigenschaften: Ganze Zahlen: 2, 4711, -45, ... Reelle Zahlen: -3.4, , -3.4e-10, e123, ... Buchstaben: `a`, `b`, ... Zeichenketten: „hello world!“, ... ... Unsinn: 3 + „hello“ Unterschiedliche Daten benötigen unterschiedlich viel Platz boolesche Werte: 1 Bit ASCII-Zeichen: 7 Bit Motivation für Datentypen: Überprüfung „sinnvoller“ Operationen Reservierung von „passendem“ Speicherplatz

13 Variablen / Datentypen
Einfache Datentypen in Java: boolean entweder true oder false char 16-Bit-Unicode byte 8-Bit-Integer, vorzeichenbehaftetes 2er-Komplement short 16-Bit-Integer, vorzeichenbehaftetes 2er-Komplement int 32-Bit-Integer, vorzeichenbehaftetes 2er-Komplement long 64-Bit-Integer, vorzeichenbehaftetes 2er-Komplement float 32-Bit-Gleitkommazahl (IEEE ) double 64-Bit-Gleitkommazahl (IEEE ) Wertebereiche beschränkt: int: [ ] int i = ; i = i + 1; i:

14 Variablen / Datentypen
Default Kleinster Wert Größter Wert boolean false N.A. N.A. char `\u0000` \u0000 \uFFFF byte short int long 0L float 0.0F E+38 E-45 double E+308 E-324

15 Variablen / Initialisierung
Initialisierung von Variablen implizit durch Default-Werte explizit mit Hilfe von Literalen bzw. Ausdrücken Empfehlung: Variablen immer explizit initialisieren! Literale: Typspezifische Konstanten boolean: true, false int: Zeichenketten aus oktalen (führende 0): 035 dezimalen 29 hexadezimalen Ziffern (führendes 0x): 0x1D

16 Variablen / Initialisierung
long: int-Literal mit nachgestelltem l oder L: 29L 4321l double: Dezimalzahlen mit Dezimalpunkt und optionalem Exponent: e1 .18E-2 float: double-Literal mit nachgestelltem f oder F: 18.0f 1.8e1F char: Zeichen zwischen zwei Apostrophen: `a` `A` `2` oder Sonderzeichen mit Escape-Sequenz: `\n` `\“` `\\` Strings: Zeichen zwischen zwei Anführungszeichen: „hello\n world“

17 Ausdrücke / Motivation
Notwendig für *2 , *3 und *4: Operationen ( Mathematik) Operatoren Operanden Sinn und Zweck: Berechnung neuer Werte aus alten Werten Beispiel: int anzahl = 0; anzahl = anzahl + 1; Operator Operand Operand

18 Ausdrücke / Definition
Ausdruck: Verarbeitungsvorschrift, deren Ausführung einen Wert eines bestimmten Typs liefert entsteht, indem Operanden mit Operatoren verknüpft werden Operanden müssen typkonform sein! <Ausdruck> ::= <Literal> | <Variablenname> | <Funktionsaufruf> | „(“ <Ausdruck> „)“ | <unär-Op> <Ausdruck> | <Ausdruck> <binär-Op> <Ausdruck> | <Ausdruck> <ternär-Op1> <Ausdruck> <ternär-Op2> <Ausdruck>

19 Ausdrücke / Operatoren / Übersicht
Integer-Arithmetik (int, short, long): +, -, *, /, % Gleitkomma-Arithmetik (float, double): +, -, *, / Boolesche Arithmetik (boolean): &&, ||, ! Vergleichsoperatoren: ==, !=, <, >, <=, >= Zuweisungsoperatoren: =, +=, -=, *=, /=, %= Inkrement-Operator: ++ Dekrement-Operator: -- Bit-Operatoren: <<, >>>, &, |, ~, ^, ... Spezielle Operatoren: ?:, (type)

20 Ausdrücke / Operatoren / integer-Arithmetik
Operanden vom Typ int, short oder long gelieferter Wert vom Typ int, short bzw. long +: positives Vorzeichen -: negatives Vorzeichen +: Addition (= 110) -: Subtraktion (= -86) *: Multiplikation 6 * 5 (= 30) /: Ganzzahl-Division 7 / 3 (= 2) %: Restbildung (modulo) 7 % 3 (= 1)

21 Ausdrücke / Operatoren / Gleitkomma-Arithmetik
Operanden vom Typ float oder double gelieferter Wert vom Typ float oder double +: positives Vorzeichen e3 -: negatives Vorzeichen e-5 +: Addition (= 11.0) -: Subtraktion (= -8.6) *: Multiplikation * 5.0 (= 30.5) /: Ganzzahl-Division / 2.0 (= 4.5) Rundungsfehler möglich!

22 Ausdrücke / Operatoren / boolesche Arithmetik
Operanden vom Typ boolean gelieferter Wert vom Typ boolean &&: Konjunktion true && false (= false) ||: Disjunktion true || false (= true) !: Negation !true (= false)

23 Ausdrücke / Operatoren / Vergleiche
Operanden vom Typ int, short , long,float, double oder char gelieferter Wert vom Typ boolean ==: Gleichheit 4 == 5 (= false) !=: Ungleichheit 6 != 7 (= true) <: Kleiner < 0.1 (= true) <=: Kleiner-Gleich 3 <= 3 (= true) >: Größer `a` > `b` (= false) >=: Größer-Gleich 1 >= -1 (= true)

24 Ausdrücke / Operatoren / Zuweisung
Operanden von beliebigem Typ gelieferter Wert vom Typ der Operanden <Zuweisung> ::= <Variablenname> „=“ <Ausdruck> „;“ int i = 0, j = -34; // Initialisierung i = 45; // Zuweisung i = i + 3; j = i = j + i*3; Abkürzungen: i i = i+1; i i = i-1; i += <expr> i = i + (<expr>) i -= <expr> i = i - (<expr>) i *= <expr> i = i * (<expr>) i /= <expr> i = i / (<expr>) i %= <expr> i = i % (<expr>)

25 Ausdrücke / Operatoren / Bedingungsoperator
ternärer Operator erster Operand vom Typ boolean Operanden zwei und drei typkonform int i = 45, j = 46; int k = i<j ? i-1 : j+2; int k = 0; if (i<j) k = i-1; else k = j+2;

26 Ausdrücke / Operatoren / Typumwandlungen
einige Typumwandlungen implizit: short int long float double arithmetisch Gleitkomma char int short s = 3; int i = s; long l = i = s; float f = 3.4F; double d = f * 2.3; float g = 3 + i; int b = `a`; ´z` - `a` ASCII-Repräsentation

27 Ausdrücke / Operatoren / Typumwandlungen
Explizite Typumwandlung (Typcast): <Cast> ::= „(“ <Typ> „)“ double d = 7.99; int i = (int) d; // i == 7 int zahl = 33000; short s = (short)zahl; // Abschneiden der oberen Bits // s == Nicht alle Typumwandlungen sind erlaubt: int wahr = (int)true; // Fehler!!!

28 Ausdrücke / Operatoren / Präzedenz
Liste mit absteigender Präzedenz: Postfix-Operatoren [], ., ++, -- unäre Operatoren +, -, ~, ! Erzeugung / Typumwandlung new, (type) Multiplikationsoperatoren *, /, % Additionsoperatoren +, - Gleichheitsoperatoren ==, != logische Und && logisches Oder || Bedingungsoperator ?: Zuweisungsoperatoren =, +=, *=, ... Abänderung der Präzedenz durch Klammernsetzung möglich!

29 Ausdrücke / Operatoren / Assoziativität
wichtig bei Operatoren gleicher Präzedenz alle unären Operatoren sind rechts-assoziativ alle binären Operatoren außer den Zuweisungsoperatoren sind links-assoziativ Zuweisungsoperatoren sind rechts-assoziativ der ternäre Bedingungsoperator (?:) ist rechts-assoziativ Assoziativität ist von Bedeutung bei Funktionen mit Seiteneffekten! i = j *= k + 78; i = (j *= (k + 78)); i = j * k / 5; i = (j * k) / 5;

30 Ausdrücke / Operatoren / Auswertungsreihenfolge
Operanden werden immer von links nach rechts ausgewertet werden wichtig bei Seiteneffekten! jeder Operand wird vor der Ausführung des Operators ausgewertet; Ausnahmen: &&, || und ?: p && q p ? q : false p || q p ? true : q o1 ? o2 : o3 werte o1 aus; falls true, werte o2 ansonsten o3 aus

31 Variablen und Ausdrücke / Zusammenfassung
Motivation: Der Hamster soll bis zur nächsten Wand laufen, dabei alle Körner einsammeln, die er findet, und an der Wand genauso viele Körner ablegen, wie er eingesammelt hat. Programm: int anzahl = 0; while (vornFrei()) { vor(); while (kornDa()) { nimm(); anzahl = anzahl + 1; } while ( anzahl > 0 ) { gib(); anzahl = anzahl -1;

32 Beispiele / Fakultät import java.io.*; public class Fakultaet {
public static void main (String[] args) { int fak = 1; int n = 7; int zaehler = 1; while (zaehler <= n) { fak = fak * zaehler; zaehler = zaehler + 1; } System.out.println(fak); fak: n: zaehler:

33 Variablen und Ausdrücke / Beispiel
import java.io.*; public class Fibonacci { public static void main (String[] args) { int lo = 1; int hi = 1; System.out.println(lo); while (hi < 20) { System.out.println(hi); hi = lo + hi; // neues hi lo = hi - lo; // neues lo (= altes hi) } lo: hi:

34 Erweiterung des Hamster-Modells
Variablendefinition (int anzahl = 0;) neue Anweisung (lokale Variable) neue Definition (globale Variable) Zuweisung(en) (anzahl = 3;) arithmetische Ausdrücke (anzahl = anzahl + 1;) Erweiterung der booleschen Ausdrücke (anzahl > 0) Achtung: Der Gültigkeitsbereich einer Variablen beschränkt sich auf den Block, in dem die Variable definiert wurde! Im Falle einer Variablendefinition als Anweisung beginnt der Gültigkeitsbereich ab der Stelle der Definition! In dem Gültigkeitsbereich einer Variablen darf keine Variable gleichen Namens definiert werden!

35 Erweiterung des Hamster-Modells
Aufgabe: Der Hamster soll bis zur nächsten Wand laufen, dabei alle Körner einsammeln, die er findet, und an der Wand genauso viele Körner ablegen, wie er eingesammelt hat. Korrektes Programm mit globaler Variable anzahl: void sammle() { while (kornDa()) { nimm(); anzahl = anzahl + 1; } void legeAb() { while (anzahl > 0) { gib(); anzahl = anzahl - 1; int anzahl = 0; void main() { sammle(); while (vornFrei()) { vor(); } legeAb();

36 Erweiterung des Hamster-Modells
Aufgabe: Der Hamster soll bis zur nächsten Wand laufen, dabei alle Körner einsammeln, die er findet, und an der Wand genauso viele Körner ablegen, wie er eingesammelt hat. Fehlerhaftes Programm mit zwei lokalen Variablen anzahl: void sammle() { int anzahl = 0; while (kornDa()) { nimm(); anzahl = anzahl + 1; } } void legeAb() { int anzahl; while (anzahl > 0) { gib(); anzahl = anzahl - 1; void main() { sammle(); while (vornFrei()) { vor(); } legeAb();