Algorithmen und Datenstrukturen II

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Algorithmen und Datenstrukturen II AG Praktische Informatik Technische Fakultät Vorlesung Sommer 2009

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Veranstalter Vorlesung und Übungen Raum: M3-124 Tel.: 0521/106-2906 Email: psteffen@techfak.uni-bielefeld.de

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Webseite zur Vorlesung Informationen zur Vorlesung und den Übungen Folien, Skript, Übungszettel http://www.techfak.uni-bielefeld.de/ags/pi/lehre/ AuDIISS09/

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Webseite zur Vorlesung Informationen zur Vorlesung und den Übungen Folien, Skript, Übungszettel http://www.techfak.uni-bielefeld.de/ags/pi/lehre/ AuDIISS09/ Account-Antrag: https://www.techfak.uni-bielefeld.de/rechner/ accountantrag.html Abholung nach ca. 2 Tagen im Support-Büro M3-100.

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Übungsgruppen Anmeldung zu den Übungen durch Eintrag auf den Listen am schwarzen Brett der Technischen Fakultät Zeitraum der Anmeldung: Dienstag 14.4., ca. 15 Uhr bis Donnerstag 16.4., 16 Uhr Raumnummern und Tutoren werden ab Freitag, dem 17.4., am schwarzen Brett bekanntgegeben

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Aufgabenzettel erstes Übungsblatt am 21.4. (dann jeweils am Dienstag in der Vorlesung) Aufgaben in Gruppen von 3 Studierenden bearbeiten Lösungen werden eine Woche nach der Ausgabe in der Vorlesung eingesammelt Leistungsnachweis: 1 mindestens 50% der möglichen Punktzahl in den Übungszetteln 2 erfolgreiche Bearbeitung der Projektaufgabe 3 regelmäßige aktive Teilnahme an den Übungen. Es darf maximal zweimal unentschuldigt gefehlt werden. Ansonsten ist ein ärztliches Attest erforderlich. Die Übungen beginnen in der Woche vom 20.04 bis 24.04.

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Einzelprojekt Vorbereitung auf TdPE Veranstaltung Java-Programmieraufgabe als Einzelarbeit Ausgabe der Projektaufgabe am 23.06.09 Abgabe der Lösungen spätestens am 14.07.09

Syntax und Semantik Java: Der Einstieg Imperative Programmierung in Java Algorithmen zur exakten Suche in Texten Objektori Übersicht 1 Syntax und Semantik 2 Java: Der Einstieg 3 Imperative Programmierung in Java 4 Algorithmen zur exakten Suche in Texten 5 Objektorientierte Programmierung in Java 6 Übergang von funktionaler zu OOP 7 Programmieren im Großen 8 Hashing 9 Ein- und Ausgabe 10 Grafische Benutzeroberflächen 11 Graphen

Teil I Syntax und Semantik

Einführung Programmiersprachen sind formale Sprachen. Es ist präzise festgelegt, welche Zeichenreihen überhaupt Programme einer Sprache L sind (Syntax), welche Ein-/Ausgabefunktion ein Programm berechnet (Semantik).

Konkrete/abstrakte Syntax konkrete Syntax Genaue textuelle Aufschreibung für Programme. abstrakte Syntax Bindeglied zur Semantik; gibt an, wie ein Programm(-stück) aufgebaut ist.

Beispiel abstrakt assign x add var const y 5

Beispiel abstrakt konkret assign x := y + 5 Pascal x = y + 5 C, Fortran, Java x add LET x = y + 5 Basic (anno 1963) ADD 5 TO y GIVING x COBOL STORE y + 5 TO x dbase var const y 5

Operatoren und Konstrukte In der abstrakten Syntax tauchen die primitiven Konstrukte einer Programmiersprache auf, sowie Operatoren, die diese zu neuen Konstrukten kombinieren. primitiv: Bezeichner, Zahl Kombination: var: Bezeichner Ausdruck const: Zahl Ausdruck add: Ausdruck Ausdruck Ausdruck assign: Bezeichner Ausdruck Anweisung

Wörter Definition Ein Alphabet A ist ein endlicher Zeichenvorrat (eine endliche Menge). Die Mengen aller endlichen Zeichenreihen über einem Alphabet A bezeichnen wir mit A. Das leere Wort der Länge 0 bezeichnen wir mit ε.

Formale Sprachen Definition Eine Menge L A heißt formale Sprache über dem Alphabet A. Einen abstrakteren Sprachbegriff kann man kaum definieren. Die einzige Frage, die man sich über w A stellen kann, ist: Gilt w L oder w L? Diese Frage nennt man das Wortproblem von L.

Programmiersprachen Definition Eine Programmiersprache ist ein Paar (L, L), wobei L A eine formale Sprache und L : L (A A ) die Semantik von L ist. Damit ordnet L jedem L-Programm l L als seine Bedeutung die Ein-/Ausgabefunktion L(l) zu, wobei Ein- und Ausgabe ebenfalls Zeichenreihen über A sind. Für L(l) schreiben wir auch kurz Ll.

Kontextfreie Grammatiken Definition Eine kontextfreie Grammatik ist ein 4-Tupel G = (N, A, P, S), wobei 1 N ein Alphabet von sogenannten Nonterminalsymbolen, 2 A ein Alphabet von sogenannten Terminalsymbolen mit N A =, 3 P eine endliche Menge von Produktionen (Regeln) der Form V α mit V N und α (V A) und 4 S N ein Startsymbol ist.

Satzformen einer Grammatik Die Menge S(G) der Satzformen von G ist die kleinste Teilmenge von (N A) mit den folgenden Eigenschaften: 1 S S(G). 2 Wenn αv β S(G) für ein Nonterminalsymbol V N und Zeichenfolgen α, β (N A) und wenn V γ P eine Regel ist, so gilt auch αγβ S(G) ( Ableitungsschritt ).

Sprache einer Grammatik Die durch G definierte Sprache ist L(G) def = S(G) A. Den Test, ob ein gegebenes Wort w durch eine Grammatik G erzeugt werden kann, also ob w L(G) gilt, nennt man das Wortproblem von G.

Syntax und Semantik von Sprachen: Bohrkopfsteuerung N W E O S N, E, W, S: Bewegung um 1 Gitterpunkt (north, east, west, south) O: Einstellen auf Nullpunkt (origin) D: Senken des Bohrkopfes mit Bohrung (drill) U: Heben des Bohrkopfes (up)

Programme zur Maschinensteuerung ONNNEEDO Bohrung am Punkt (2,3) mit Rückkehr zum Nullpunkt ODUDUDU DUNDUWDUSDU Dreifach-Bohrung am Nullpunkt bohrt Gitterquadrat, wo der Kopf gerade steht

Steuersprache In der ersten Variante unserer Steuersprache lassen wir beliebige Befehlsfolgen zu. Außerdem kann jedes Programm als Eingabe ein Paar von Start-Koordinaten erhalten. L 1 = {N, E, W, S, U, D, O} Eingabe: (Int, Int) L 1 : L 1 (Int, Int) [(Int, Int)]

Maschinenzustand x y l cs aktuelle x-koordinate aktuelle y-koordinate aktueller Hebezustand des Bohrkopfes: 0 gesenkt, 1 oben Liste bisheriger Bohr-Koordinaten

Semantik von Befehlen bef :: Befehl Zustand Zustand bef b (x, y, l, cs) = case b of O (0, 0, 1, cs) N (x, y + 1, l, cs) W (x 1, y, l, cs) S (x, y 1, l, cs) E (x + 1, y, l, cs) D (x, y, 0, (x, y) : cs) U (x, y, 1, cs)

Befehlsfolgen beff :: Befehl Zustand [(Int, Int)] beff [ ](x, y, l, cs) = reverse cs beff (b : bs)(x, y, l, cs) = beff bs(bef b (x, y, l, cs))

Befehlsfolgen beff :: Befehl Zustand [(Int, Int)] beff [ ](x, y, l, cs) = reverse cs beff (b : bs)(x, y, l, cs) = beff bs(bef b (x, y, l, cs)) Die Semantik L 1 wird beschrieben durch die Funktion prog :: Befehl (Int, Int) [(Int, Int)] prog bs (i, j) = beff bs (i, j, 1, [])

Programmiersprache L 1 und ihre Semantik L 1 sind sehr naiv. Man sollte zum Beispiel bedenken, dass das Werkstück und vielleicht auch die Maschine beschädigt werden, wenn mit abgesenktem Bohrkopf Bewegungen ausgelöst werden. Freilich solange niemand solche Steuerprogramme erzeugt, geht alles gut. Jedoch wollen wir uns nicht darauf verlassen...

Syntaktische vs. semantische Verfeinerung Generell gibt es zwei Möglichkeiten, eine Sprache (L, L) zu verfeinern: syntaktisch oder semantisch. Semantisch heisst: das Unglück kann programmiert werden, tritt aber nicht ein. Syntaktisch heisst: das Unglück wird bereits als syntaktisch fehlerhaftes Programm abgewiesen.

Aufgabe Modifiziere die Semantik L 1 (bei unverändertem L 1 ) in zwei verschiedenen Weisen. Tritt eine Bewegung mit abgesenktem Bohrkopf auf, so wird a) die Ausführung des Programms abgebrochen und nur die Koordinaten der bisherigen Bohrungen ausgegeben, b) die Ausführung des Programms abgebrochen und keine Koordinaten angegeben.

Forderungen an die Steuersprache Wir entscheiden uns nun für die syntaktische Verfeinerung und stellen Forderungen an die Steuersprache L: 1 Auf Befehl D muss stets U oder O folgen. 2 Befehl O ist immer möglich, U nur unmittelbar nach D. 3 Alle Programme enden mit dem Bohrkopf am Nullpunkt. 4 Auf dem Weg von einer Bohrung zur nächsten sind gegenläufige Richtungswechsel unerwünscht, zum Beispiel... NSNS... oder... NES..., weil sie die Maschine in Schwingung versetzen können. Alle diese Forderungen lassen sich durch Einschränkungen von L 1 erfüllen, erfordern aber verfeinerte Methoden zur syntaktischen Sprachbeschreibung. Solche Mittel sind Grammatiken.

Grammatik 1 Grammatik G 1 (zur Beschreibung von L 1 ) A = { N, E, W, S, U, D, O} N = { moves, move} S = moves P = { moves ε move moves move N E W S U D O}

Grammatik 1 Grammatik G 1 (zur Beschreibung von L 1 ) A = { N, E, W, S, U, D, O} N = { moves, move} S = moves P = { moves ε move moves move N E W S U D O} Hier gilt L(G 1 ) = A. Es ist w L(G 1 ) mit w = WENDEDENUDOSUED Übung: Leite w mit dieser Grammatik ab.

Verfeinerte Grammatik 2 Verfeinerte Grammatik G 2 (berücksichtigt Forderungen (1) - (3), aber nicht (4)). A, N, S wie G 1 P = { moves O DO move moves move N E W S O DU DO}

Verfeinerte Grammatik 2 Verfeinerte Grammatik G 2 (berücksichtigt Forderungen (1) - (3), aber nicht (4)). A, N, S wie G 1 P = { moves O DO move moves move N E W S O DU DO} Frage: Warum brauchen wir die Regel moves DO überhaupt?

Verfeinerte Grammatik 2 Verfeinerte Grammatik G 2 (berücksichtigt Forderungen (1) - (3), aber nicht (4)). A, N, S wie G 1 P = { moves O DO move moves move N E W S O DU DO} Frage: Warum brauchen wir die Regel moves DO überhaupt? Antwort: Sonst ist DO / S(G 2 ).

Warum ist nun w = WENDEDENUDOSUED / S(G 2 )? Versuch einer Ableitung: moves move moves W moves W move moves W E moves 3 W E N move moves W E N? Hier kann nur DU oder DO erzeugt werden, aber nicht D allein oder DE.

Verfeinerte Grammatik 3 Verfeinerte Grammatik G 3 (berücksichtigt Forderungen (1) und (4), (2) nur teilweise und (3) gar nicht): A, S wie G 1 N = { moves, ne, nw, se, sw, drill } P = { moves ε ne moves nw moves se moves sw moves ne N ne E ne drill se S se E se drill nw N nw W nw drill sw S sw W sw drill drill DU DO }

RNA-Sekundärstrukturen Ein RNA-Molekül besteht aus Basen A,C,G,U. Durch Wasserstoff-Brücken zwischen A U, G C, G U bilden sich Basenpaarungen, die zu einer Sekundärstruktur führen. Primärsequenz C A C C U A A G G U C C Sekundärstruktur C A C C U A A G G U C C C A U C C C G U C A G Helix-Bildung schafft St A

Sekundärstruktur-Grammatik Grammatik zur Beschreibung der Sekundärstruktur (Ausschnitt): A = { A, C, G, U } N = { struct, any, stack, loop } S = struct P = { struct any any struct struct any stack ε any A C G U stack A stack U U stack A G stack C C stack G G stack U U stack G loop loop any loop any any any }

Ableitung von RNA-Sequenzen Allein mit den ersten beiden Produktionen kann man alle RNA-Sequenzen ableiten: struct any struct A struct A any struct AC struct... Damit ist L(G) = A. Der Witz der Grammatik ist, dass manche Ableitungen das Vorliegen möglicher Sekundärstrukturen anzeigen dann nämlich, wenn sie die Produktionen für stack benutzen.

Ableitung == Struktur struct 2 C struct 4 C struct CC C stack CC CA stack UCC 2 CACC stack GGUCC CACC loop GGUCC 4 CACCUAAGGUCC

Syntaxbaum struct any struct C struct any any C struct C stack U A C C any stack U stack G stack G loop any any A A

EBNF, Historisches Syntaxbeschreibung von FORTRAN und COBOL (am Anfang) durch Beispiele und Gegenbeispiele. 1958 formale Beschreibung der Syntax von ALGOL durch John Backus; Backus-Normalform (BNF). Kleine Verbesserungen in der Notation durch Peter Naur, daher spricht man heute von der Backus-Naur-Form (BNF). Niklaus Wirth hat die Backus-Naur-Form noch einmal überarbeitet und erweitert (EBNF Extended BNF).

EBNF, Definition Die Metazeichen der EBNF (vgl. Klaeren [5], S. 104) sind: das Definitionszeichen = das Alternativzeichen die Anführungszeichen die Wiederholungsklammern { } die Optionsklammern [ ] die Gruppenklammern ( ) der Punkt.

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol.

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol.

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol. 3 Für α ET sind auch

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol. 3 Für α ET sind auch 1 (α) ET,

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol. 3 Für α ET sind auch 1 (α) ET, 2 [α] ET und

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol. 3 Für α ET sind auch 1 (α) ET, 2 [α] ET und 3 {α} ET.

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol. 3 Für α ET sind auch 1 (α) ET, 2 [α] ET und 3 {α} ET. 4 Für α 1,..., α n ET sind auch

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol. 3 Für α ET sind auch 1 (α) ET, 2 [α] ET und 3 {α} ET. 4 Für α 1,..., α n ET sind auch 1 α 1... α n ET und

EBNF, Terme Die Menge ET der EBNF-Terme ist gegeben durch: 1 Ist V eine Folge von Buchstaben und Ziffern, die mit einem Buchstaben beginnt, so gilt V ET und gilt als Nonterminalsymbol. 2 Ist w eine Folge von beliebigen Symbolen, so ist w ET und gilt als ein (!) Terminalsymbol. 3 Für α ET sind auch 1 (α) ET, 2 [α] ET und 3 {α} ET. 4 Für α 1,..., α n ET sind auch 1 α 1... α n ET und 2 α 1 α 2... α n ET.

EBNF-Definitionen Eine EBNF-Definition besteht aus einer endlichen Menge von EBNF-Regeln der Form V = α. wobei V ein Nonterminalsymbol entsprechend obiger Konvention und α ein EBNF-Term ist. Das Nonterminalsymbol auf der linken Seite der ersten Regel ist das Startsymbol.

EBNF-Definition für Mini-Java (1) program = class ident { mainmethod }. mainmethod = public static void main ( String [ ] argsident ) bloc statement = int ident = expression ; ident = expression ; if ( condition ) statement while ( condition ) statement block System. out. println ( expression ) ; ; int [ ] arrayident = new int [ expression ] ; arrayident [ expression ] = expression ;. block = { { statement } }. condition = expression ( ==!= < <= > >= ) expression. expression = [ ( + - ) ] term { ( + - ) term }. term = factor { ( * / ) factor }.

EBNF-Definition für Mini-Java (2) factor = ident number ( expression ) Integer. parseint ( argsident [ expression ] ) argsident. length arrayident. length arrayident [ expression ]. ident = ( letter _ $ ) { letter digit }. number = ( 0 digit { digit 0 } ). digit = 1 2... 9. letter = A... Z a... z. argsident = ident. arrayident = ident.

Operationen auf Sprachen Seien L, L 1 und L 2 beliebige Sprachen (Wortmengen) über einem gemeinsamen Alphabet. Dann definieren wir: def 1. Komplex-Produkt: L 1 L 2 = {w 1 w 2 w 1 L 1, w 2 L 2 } (also L = L = ; L{ε} = {ε}l = L) 2. n-fache Iteration: L 0 def = {ε}, L n+1 := LL n 3. Stern-Operation: L def = n N Ln

Semantik der EBNF (1) Die Semantik der EBNF definieren wir durch Rekursion über die EBNF-Terme. Sei E eine EBNF-Definition (wobei S das Startsymbol, N die Menge der Nonterminals und A die Menge der Terminals sei) und ET die Menge der EBNF-Terme. Dann ist die von E erzeugte Sprache L(E) definiert als S E, wobei E : ET P(A ) wie folgt definiert ist (vgl. Klaeren [5], S. 107):

Semantik der EBNF (2) 1 Für V N{ ist def α E falls V = α. eine Regel in E ist V E = sonst

Semantik der EBNF (2) 1 Für V N{ ist def α E falls V = α. eine Regel in E ist V E = sonst 2 w E def = {w}

Semantik der EBNF (2) 1 Für V N{ ist def α E falls V = α. eine Regel in E ist V E = sonst def 2 w E = {w} def 3 (α) = α E E

Semantik der EBNF (2) 1 Für V N{ ist def α E falls V = α. eine Regel in E ist V E = sonst def 2 w E = {w} def 3 (α) = α E E def 4 [α] = {ε} α E E

Semantik der EBNF (2) 1 Für V N{ ist def α E falls V = α. eine Regel in E ist V E = sonst def 2 w E = {w} def 3 (α) = α E E def 4 [α] = {ε} α E E def 5 {α} = α E E

Semantik der EBNF (2) 1 Für V N{ ist def α E falls V = α. eine Regel in E ist V E = sonst def 2 w E = {w} def 3 (α) = α E E def 4 [α] = {ε} α E E def 5 {α} = α E E 6 α 1... α n E def = α 1 E... α n E

Semantik der EBNF (2) 1 Für V N{ ist def α E falls V = α. eine Regel in E ist V E = sonst def 2 w E = {w} def 3 (α) = α E E def 4 [α] = {ε} α E E def 5 {α} = α E E 6 α 1... α n E def = α 1 E... α n E 7 α 1 α n E def = α 1 E α n E

Beispiel eines syntaktisch korrekten Mini-Java-Programms class BubbleSort { public static void main(string[] args) { int[] array = new int[args.length]; int i = 0; while (i < args.length) { array[i] = Integer.parseInt(args[i]); i = i+1; } i = 1; while (i < array.length) { int j = array.length - 1; while (j >= i) { if (array[j] < array[j-1]) { int tmp = array[j]; array[j] = array[j-1]; array[j-1] = tmp; } j = j-1; } i = i+1; } i = 0; while (i < array.length) { System.out.println(array[i]); i = i+1; } } }

EBNF-Definition für Mini-Java (1) program = class ident { mainmethod }. mainmethod = public static void main ( String [ ] argsident ) bloc statement = int ident = expression ; ident = expression ; if ( condition ) statement while ( condition ) statement block System. out. println ( expression ) ; ; int [ ] arrayident = new int [ expression ] ; arrayident [ expression ] = expression ;. block = { { statement } }. condition = expression ( ==!= < <= > >= ) expression. expression = [ ( + - ) ] term { ( + - ) term }. term = factor { ( * / ) factor }.

EBNF-Definition für Mini-Java (2) factor = ident number ( expression ) Integer. parseint ( argsident [ expression ] ) argsident. length arrayident. length arrayident [ expression ]. ident = ( letter _ $ ) { letter digit }. number = ( 0 digit { digit 0 } ). digit = 1 2... 9. letter = A... Z a... z. argsident = ident. arrayident = ident.

Syntaxdiagramme für EBNF-Definitionen (1) w : w für alle w A. V : V für alle V N. [α] : α {α} : α

Syntaxdiagramme für EBNF-Definitionen (2) α 1... α n : α 1 α n α 1 α n : α 1. α n

Beispiel: Syntaxdiagramme für Mini-Java (1) program class ident { mainmethod } mainmethod public static void main ( String [ ] argsident ) block

Beispiel: Syntaxdiagramme für Mini-Java (2) statement int ident = expression ; ident = expression ; if ( condition ) statement while ( condition ) statement block System. out. println ( expression ) ; ; int [ ] arrayident = new int [ expression ] ; arrayident [ expression ] = expression ;

Beispiel: Syntaxdiagramme für Mini-Java (3) condition expression!= == expression < block { } <= >= statement >

Beispiel: Syntaxdiagramme für Mini-Java (4) expression term + term + term factor factor * /

Beispiel: Syntaxdiagramme für Mini-Java (5) factor ident number ( expression ) Integer. parseint ( argsident [ expression ] ) argsident. length arrayident. length arrayident [ expression ]

Beispiel: Syntaxdiagramme für Mini-Java (6) ident letter _ $ letter digit number digit 0 digit 0

Beispiel: Syntaxdiagramme für Mini-Java (7) letter A... digit 1 Z a...... 9 z

K. Arnold, J. Gosling: Java TM - Die Programmiersprache. Addison-Wesley, 1996. T.H. Cormen, C.E. Leierson, R.L. Rivest: Introduction to Algorithms. MIT Press, 1990. D. Flanagan: Java in a Nutshell. O Reilly & Associates Inc., 1996. F. Jobst: Programmieren in Java. Hanser Verlag, 1996. H. Klaeren: Vom Problem zum Programm. 2.Auflage, B.G. Teubner Verlag, 1991. K. Echtle, M. Goedicke: Lehrbuch der Programmierung mit Java. dpunkt-verlag, 2000.