Scala. Eine Einführung in die Programmierung. Tobias Kohn

Transkript

1 Scala Eine Einführung in die Programmierung Tobias Kohn

2 c , Tobias Kohn Version vom 3. Januar 2013

3 INHALT 1 Rechnen mit Scala Scala, der Taschenrechner Ein Gedächtnis dank Variablen Pakete öffnen und losrechnen Zahlen raten Ich denke mir eine Zahl Durchschnitte berechnen Funktionen, die mit Variablen spielen Das Spiel programmieren Zahlen raten II:Die Revanche Scala lernt Schreiben Funktionen füttern Vergleichen und Entscheiden Das zweite Spiel: Rollentausch Flip-Flop Dem Zufall in die Karten schauen Caesars Verschlüsselung Buchstaben ersetzen Wörter und Sätze speichern Von Zahlen und Zeichen Für jeden Buchstaben einmal Verschlüsseln Datentypen Eclipse Projekte erstellen Objekte und Funktionen Nachrichten ausgeben Das kleine Ein-Mal-Eins Mehr Bedingungen Über Dialoge kommunizieren Mit Rekursion zurück zum Anfang Das Ein-Mal-Eins abfragen Swing 79

4 2 Inhalt c 2013, Tobias Kohn 7.1 Das Hauptfenster Fenster und Elemente Auf Ereignisse reagieren Die Taschenrechner-Oberfläche Mit dem Taschenrechner rechnen Listen Listen und Arrays Die Primfaktor-Zerlegung Elemente finden Mathematik mit Listen Lösungen 111 Lösungen zu den Quizfragen Index 112

5 k a p i t e l e i n s RECHNEN MIT SCALA Lernziele Wie kannst du mit Scala rechnen? Wie definierst oder veränderst du in Scala eine Variable? Was ist der Unterschied zwischen Integer und Double? Wie lädst du zusätzliche Funktionen aus einem Paket? Was will dir Scala mit einer Fehlermeldung sagen? 1.1 SCALA, DER TASCHENRECHNER Worin du mit Scala rechnest und auf den Unterschied zwischen ganzen und gebrochenen Zahlen triffst. Eines vorweg: Computer sind Rechenmaschinen. Programmieren lernen heisst entsprechend, dass du lernst, den Computer für dich rechnen zu lassen. Und genau das wirst du hier tun. Bevor du also grosse Programme schreibst, beginnst du mit etwas Mathematik. Nachdem du Scala gestartet hast, meldet es sich auf dem Bildschirm: Welcome to Scala version final (Java HotSpot... Type in expressions to have them evaluated. Type :help for more information. scala> Scala ignoriert Leerzeichen und Abstände in den meisten Fällen. Ob du also lieber oder 3+4 schreibst, spielt keine Rolle. Das scala> am Schluss bedeutet, dass jetzt du an der Reihe bist, etwas einzugeben. Und weil du Programmieren nur durch selber machen lernen kannst, probierst du gleich selbst einmal folgendes aus: scala> 5+12*31 res0: Int = 377

6 4 Rechnen mit Scala c 2013, Tobias Kohn scala> 111/3 res1: Int = 37 scala> (14-6)*(14+6) res2: Int = 160 scala> 3/2 res3: Int = 1 Scala kann also rechnen. Aber wenn du dir das vierte Resultat (res3) oben noch einmal anschaust, dann siehst du, dass Scala mit der Mathematik Mühe hat. INTEGER UND DOUBLE Natürlich kann Scala auch 3 durch 2 richtig teilen. Und zwar so: scala> 3.0/2.0 res4: Double = 1.5 Warum ist das Ergebnis ein anderes, wenn da 3.0 anstatt 3 steht? Weil Scala von sich aus folgende Annahme trifft: Wenn die Zahlen in der Eingabe ganzzahlig sind, dann soll auch das Resultat ganzzahlig sein. Alles klar? Scala rechnet also nur mit Nachkommastellen, wenn die Zahlen schon von Anfang an Nachkommastellen haben. Im Prinzip genügt es auch, mindestens einer Zahl Nachkommastellen zu geben. Aber vorsicht: Das führt nicht immer zum richtigen Resultat. scala> 3.0/2 res5: Double = 1.5 scala> 1.0+3/2 res6: Double = 2.0»Int«und»Double«geben an, ob die verwendeten Zahlen ganzzahlig oder gebrochen sind. Wir sprechen auch vom Datentyp einer Zahl. Im zweiten Fall rechnet Scala zuerst 3/2 mit ganzen Zahlen aus und verwendet erst danach für die Addition Nachkommastellen. Dann ist der Fehler aber bereits passiert! Beim Programmieren heissen ganze Zahlen Integer und gebrochene Zahlen (mit Nachkommastellen) Double. Scala kürzt das Integer zu Int ab. Schau dir noch einmal die Ausgaben an: Scala gibt immer an, ob das Resultat ganzzahlig (Int) oder gebrochen (Double) ist. Den Datentypen Int und Double wirst du im folgenden immer wieder begegnen. Sie sind wichtig, weil das Resultat je nachdem ein anderes ist.

7 c 2013, Tobias Kohn Scala, der Taschenrechner 5 GENAUIGKEIT Bei der Diskussion über Integer und Double drängt sich eine Frage auf: Warum verwendet man nicht gleich immer Double-Werte und rechnet exakt, d. h. mit allen Nachkommastellen? Der Computer basiert alle seine Zahlen auf Potenzen von 2. Er setzt also seine Zahlen zusammen aus 8, 4, 2, 1, 0.5, 0.25, etc. Während er damit alle natürlichen Zahlen genau angeben kann, lassen sich gebrochene Werte wie 0.1 oder 0.2 nur näherungsweise darstellen. Deshalb entstehen diese Rundungsfehler hier. Zum Vergleich: 3 lässt sich mit unseren 1 Dezimalzahlen auch nicht genau, sondern nur näherungsweise darstellen: = =? 1 Darauf gibt es viele Antworten. Zum Zählen sind die ganzzahligen Integer- Werte zum Beispiel besser geeignet als gebrochene Zahlen. Vor allem aber sind auch Double-Werte nicht genau, sondern immer Rundungen! Schau dir diese Rechnungen hier einmal an: scala> res7: Double = scala> 0.1 * 7 * 10 res8: Double = Der Computer tut sein Bestes, die Rundungsfehler zu verstecken. Aber manchmal braucht es sehr wenig, um diese Rundungsfehler sichtbar zu machen. Programme für Banken rechnen aus diesem Grund übrigens grundsätzlich mit Integer-Werten (und in Cents bzw. Rappen), um Rundungsfehler wie oben zu vermeiden. Also: Double-Werte sind nicht»genauer«als Integer-Werte, sondern immer mit Rundungsfehlern verbunden! Bei komplexen Berechnungen summieren sich die Rundungsfehler manchmal so weit auf, dass die Resultate unbrauchbar werden. RESULTATE RECYCLEN* Hast du eine Zahl berechnet und möchtest damit weiterrechnen? Magst du die Zahl nicht selber wieder abtippen? Kein Problem: Scala speichert (fast) alle Resultate in Variablen, die du dann einfach wieder zum Rechnen verwendest. Die Resultate heissen res#, hier z. B. res9 bis res11. scala> 1 * 2 * 3 * 4 * 5 res9: Int = 120 scala> res9 * 6 res10: Int = 720 scala> (res10 - res9) / 2 res11: Int = 300

8 6 Rechnen mit Scala c 2013, Tobias Kohn 1.2 EIN GEDÄCHTNIS DANK VARIABLEN Worin du eigene Variablen definierst, verwendest und dich damit nicht an alle Zahlenwerte erinnern musst. Für kompliziertere Rechnungen ist es hilfreich, Zwischenresultate in Variablen zu speichern. Neuen Variablen stellst du dazu ein var voran: Variablen sind beim Programmieren enorm wichtig, um Werte zwischenzuspeichern. Beachte, dass bei Scala die Gross- und Kleinschreibung eine Rolle spielt. a und A sind für Scala also verschiedene Variablen. scala> var x = 123 x: Int = 123 scala> var tausend = 1000 tausend: Int = 1000 x steht jetzt für den Integer-Wert 123. Danach kannst du die Variablen in deinen Rechnungen nach Belieben verwenden: scala> x*3 + tausend res12: Int = 1369 Allerdings kann Scala nicht symbolisch rechnen: Alle Variablen, die du verwendest, müssen einen Wert haben. Ansonsten reklamiert Scala mit einer Fehlermeldung. scala> a+b <console>:10: error: not found: value a Damit sagt dir Scala, dass es für die Variable a keinen (Zahlen-)Wert gefunden hat und daher nicht damit rechnen kann (dass es b auch nicht kennt, spielt hier gar keine Rolle mehr). Variablen sind eine hervorragende Möglichkeit, um Zahlenwerte für später zu speichern und dann wieder zu verwenden. Du kannst den Zahlenwert in einer Variablen auch jederzeit wieder ändern. Allerdings unterscheiden sich Variablen für Integer von Variablen für Double: Entsprechend kannst du also keinen Double-Wert in einer Integer-Variablen speichern. Mit var legst du jeweils neue Variablen an. Dabei wird immer auch gleich der Datentyp festgelegt.

9 c 2013, Tobias Kohn Ein Gedächtnis dank Variablen 7 VARIABLENWERTE ÄNDERN Den Wert einer Variable kannst du auch ändern. Das var brauchst du nur, wenn du eine Variable neu definierst. Danach lässt du es weg. Wenn du eine Variable vom Typ Integer definierst, dann kannst du nachher keine Double-Werte darin speichern, sondern wirklich nur Integer. Umgekehrt enthält eine Variable vom Typ Double immer gebrochene Zahlen. scala> var gold = gold: Double = scala> gold - 1 res13: Double = scala> gold = 42 res14: Double = 42.0 scala> gold * gold res15: Double = In der Mathematik ist das Gleichheitszeichen symmetrisch, beim Programmieren aber nicht. Du darfst also nicht 1 = x schreiben. Die Variable muss immer links stehen. AUFGABEN 1. Definiere eine Variable v und finde heraus, was die folgende Eingabe in Scala bewirkt. Findest du noch weitere, ähnliche Operationen? scala> v += 1 2. Neben den vier Grundoperationen gibt es in Scala noch eine fünfte mit dem Operationszeichen % (das Prozentzeichen steht hier nicht für Prozent!) Für welche Operation steht das Zeichen? Was berechnet Scala dabei? scala> 12 % 5 res16: Int = 2 3. Fehlermeldungen:»type mismatch«lässt sich übersetzen mit»unpassender Datentyp«. Was ist hier falsch gelaufen? Warum reklamiert Scala und wie könntest du den Fehler beheben? scala> var x = 1 x: Int = 1 scala> x = 1.5 <console>:8: error: type mismatch; found : Double(1.5) required: Int x = 1.5 x = ˆ

10 8 Rechnen mit Scala c 2013, Tobias Kohn 1.3 PAKETE ÖFFNEN UND LOSRECHNEN Worin ein Paket nicht verschickt wird, sondern Befehle und Variablen enthält. Auch der Zufall ist sauber in einem Paket verschnürt. In Scala gibt es Tausende von verschiedenen Funktionen und Datenstrukturen. Sie sind in speziellen Dateien gespeichert und bevor du eine solche Funktion verwendest, musst du Scala zuerst angeben, in welcher Datei die Funktion definiert ist. PAKETE Dateien, die zusätzliche Variablen und Funktionen enthalten, heissen Pakete oder nach dem Englischen Packages (manchmal findest du auch den Begriff Bibliothek). Scala kennt dutzende von verschiedenen Paketen und eines davon ist das Mathematikpaket math. Es enthält die üblichen mathematischen Funktionen und die Variable Pi für π. Für dich ist die Frage relevant: Wie kannst du Variablen und Funktionen aus einem bestimmten Paket verwenden? Am Beispiel der Wurzelfunktion sqrt zeige ich dir, wie das geht. WURZELN ZIEHEN Die Wurzelfunktion heisst sqrt (vom englischen»square root«für»quadratwurzel«) und ist im Paket math definiert. Um die Funktion sqrt zu verwenden gibst du vor dem Namen das entsprechende Paket an: Mit»import«kannst du eine Variable oder Funktion aus einem Paket heraufladen und dann direkt verwenden (ohne das Paket angeben zu müssen). scala> math.sqrt(2) res17: Double = Auf die Dauer ist es aber sehr mühsam, immer das Paket mitangeben zu müssen. Es ist deshalb sinnvoller, die Funktion sqrt mittels import ganz aus der Datei zu laden. scala> import math.sqrt Für das Mathematikpaket math existiert auch der längere Name scala.math. Beide Formen sind gleichwertig. scala> sqrt(2) res18: Double = Das funktioniert auch mit Pi: scala> import math.pi scala> Pi res19: Double =

11 c 2013, Tobias Kohn Pakete öffnen und losrechnen 9 Das Paket math enthält noch viel mehr als nur die Wurzelfunktion und π. Du findest darin grundsätzlich all die Funktionen, die du auch auf dem Taschenrechner hast (sin, cos, ln,... ). Davon stelle ich dir aber nur noch eine weitere Funktion vor: pow. Scala kennt leider kein Operationszeichen für Potenzen. Du kannst also z. B. 2 3 nicht direkt eingeben. Aber es gibt eine Funktion, um Potenzen zu berechnen. Im Englischen spricht man bei Potenzen von»power«und so trägt die Funktion den Namen pow. Pakete enthalten jeweils nützliche Zusatzfunktionen zu einem bestimmten Thema (z. B. Mathematik oder Grafikausgabe). scala> math.pow(2, 3) res20: Double = 8.0 Übrigens: Mathematische Funktionen aus dem Paket math wandeln alle Zahlen für die Berechnungen in Double um. Entsprechend ist auch das Ergebnis von diesem Typ, auch wenn 2, 3 und 8 eigentlich ganze Zahlen wären. KEINE NUMMER Bei der Arbeit mit Double-Werten kann es dir passieren, dass das Ergebnis einmal NaN ist. NaN steht für»not a number«und bedeutet, dass sich die richtige Zahl nicht berechnen lässt. scala> math.sqrt(-1) res21: Double = NaN Falls du ein NaN erhältst, dann überprüfe deine Berechnungen! ALLES LADEN Sobald du mehr als ein oder zwei Funktionen aus einem Paket brauchst, wird es bereits wieder umständlich, alle einzeln mit import zu laden. Für diesen Fall kennt Scala die Möglichkeit, gleich alle Funktionen und Variablen aus einem Paket zu laden. Dabei dient der Unterstrich als Zeichen für»alles«. scala> import math._ scala> sqrt(pi) res22: Double = Es ist allerdings nicht sinnvoll, alles zu laden, wenn du dann doch nur eine einzelne Funktion brauchst. ZUFALLSZAHLEN Die Diskussion über Pakete schliesse ich mit den Zufallszahlen ab. Diese kommen aus einem anderen Paket, nämlich util. Zur Erzeugung von Zufallszahlen gibt es einen Zufallszahlen-Generator mit dem Namen Random (random ist wieder einmal das englische Wort für»zufällig«).

12 10 Rechnen mit Scala c 2013, Tobias Kohn Den Zufallsgenerator speicherst du am besten in einer Variable. scala> var zufall = util.random zufall: util.random.type = scala.util.random$@64abfe29 Die Variable zufall enthält danach einen Zufallsgenerator. Damit erzeugst du jetzt eine neue Zufallszahl im Bereich zwischen 0 und 10 (mit 0, aber ohne 10): scala> zufall.nextint(10) res23: Int = 5 Du kannst die Zufallszahl auch wieder in einer Variablen speichern. scala> var z = zufall.nextint(10) z: Int = 7 Die erzeugten Zufallszahlen sind immer ganze Zahlen grösser oder gleich 0, aber kleiner als die angegebene Zahl bei nextint. Wenn die Zufallszahl also zwischen 0 und 100 (einschliesslich 0 und 100) liegen soll, verwendest du: scala> zufall.nextint(101) res24: Int = 40 Wichtige Punkte Scala unterscheidet beim Rechnen zwischen den Datentypen Integer (ganze Zahlen) und Double (gebrochene Zahlen). Mit Variablen lassen sich beliebige Werte unter einem Namen speichern. Neue Variablen brauchen bei der Definition das Schlüsselwort var. Mit der Zuweisung x = 3 wird der Wert 3 in der Variable x gespeichert. Die Variable muss immer links stehen. Du kannst zwar den Wert einer Variablen verändern, nicht aber ihren Datentyp. In einer Integer-Variablen lässt sich kein Double speichern. Pakete (Packages) enthalten zusätzliche Funktionen. Mit import können die Funktionen aus dem Paket geladen werden. Falls du gleich alle Funktionen aus einem Paket laden möchtest, dann gibst du das mit dem Unterstrich _ an.

13 c 2013, Tobias Kohn Pakete öffnen und losrechnen Welche Anweisung(en) ergeben das richtige Resultat 8 (bzw. 8.0)? a. 3*8/3 b. 3*(8/3) c. 8/3*3 d. 8/3.0*3 2. Beim Versuch, den Wert 1.5 in der Variablen x zu speichern, hat Scala folgende Fehlermeldung ausgegeben: scala> x = 1.5 <console>:7: error: not found: value x Was ist der Grund für diese Fehlermeldung? a. x ist vom Typ Int und kann daher keine Double-Werte aufnehmen. b. c. x hat bereits einen Wert und kann nicht mehr geändert werden. x wurde zuvor noch nie verwendet und deshalb braucht es hier ein var vor dem x. d. x steht auf der falschen Seite: Es müsste 1.5 = x heissen. 3. Die Funktion abs(x) aus dem Paket math berechnet den Betrag x einer Zahl. Wie lädst die Funktion korrekt in Scala? a. import math.abs b. c. import abs = math.abs import math.abs(x) d. import abs from math 4. Mit welchen Anweisungen wird der Wert in der Variablen x um 1 kleiner? a. x-=1 b. x=-1 c. x=x-1 d. x-1

14 12 Rechnen mit Scala c 2013, Tobias Kohn AUFGABEN 4. Der goldene Schnitt σ erfüllt die Eigenschaft: σ 1 = 1 σ Auf der anderen Seite lässt sich σ auch mit der Formel berechnen: σ = 2 (a) Rechne σ mit Hilfe von Scala aus und speichere den Wert in einer Variablen s. (b) Berechne mit Scala und deinem Wert s beide Seiten der Gleichung oben und zeige, dass der Wert in der Variablen s die Eigenschaft ziemlich gut erfüllt. 5. Ein pythagoräisches Tripel besteht aus drei Zahlen (a, b, c), die den Satz des Pythagoras erfüllen: a 2 + b 2 = c 2 Zum Beispiel ist (3, 4, 5) ein solches pythagoräisches Tripel. Bei den folgenden Tripeln fehlt jeweils eine der drei Zahlen. Verwende Scala, um auch die dritte Zahl zu finden. Hinweis: Die gesuchten Zahlen sind alle natürliche Zahlen! (a) 5, 12 (b) 16, 65 (c) 40, * Zufallszahlen: nextint() erzeugt immer eine ganze Zahl von Null an. Du kannst damit aber auch Zufallszahlen erzeugen, die von 10 bis 19 reichen, und zwar so: scala> zufall.nextint(10) + 10 res25: Int = 14 Entwickle entsprechende»rechnungen«, um Zufallszahlen aus folgenden Mengen zu ziehen. (a) 1, 2, 3,..., 50 (b) 2, 4, 6, 8, 10 (c) 1, 3, 5, 7, 9,..., 25 (d) 10, 20, 30, 40, (e) 1, 2, 4, 8, 16, 32, (f) 10, 11, 20, 21, 30,..., 91

15 k a p i t e l z w e i ZAHLEN RATEN Lernziele Wie programmierst und verwendest du eine Funktion? Was ist der wesentliche Unterschied zwischen einer Funktion und einer Variablen? Wie funktioniert die binäre Suche? Was ist ein Block und welche Rolle spielt das Semikolon darin? 2.1 ICH DENKE MIR EINE ZAHL... Worin du das Ratespiel kennenlernst, das du später in diesem Kapitel programmieren wirst. DAS SPIEL Denk dir eine Zahl zwischen 1 und 100. Ist es 81? Zu hoch? Dann ist es bestimmt 35. Auch nicht?... Welche ist es denn? Der Computer soll erraten, welche Zahl du dir denkst. Dieses Zahlen-Raten sollst du mit dem Computer spielen können. Dazu musst dem Computer das Spiel aber zuerst beibringen, d. h. du musst den Computer so programmieren, dass er das Ratespiel mit dir spielen kann. Und zwar denkst du dir eine Zahl aus und der Computer soll sie erraten. Wenn du dir eine Zahl ausgedacht hast, könnte das Spiel am Ende so aussehen: scala> ratemal res26: Int = 81 scala> kleiner res27: Int = 35

16 14 Zahlen raten c 2013, Tobias Kohn scala> kleiner res28: Int = 22 scala> groesser res29: Int = 31 Der Computer versucht es zuerst mit 81. Das ist viel zu hoch, also gibst du ihm an, dass die gesuchte Zahl kleiner ist, worauf er eine neue Zahl probiert, usw. Sobald er die richtige Zahl errät, ist das Spiel fertig. DIE BESTE STRATEGIE Der Computer soll nicht einfach zufällig raten. Du programmierst ihm am besten eine möglichst gute Strategie ein. Er soll also mit möglichst wenig Versuchen deine Zahl erraten können. Was für eine Strategie würdest du konkret verwenden, um eine Zahl zwischen 1 und 100 möglichst schnell erraten zu können? Die»binäre Suche«gehört zu den besten Suchstrategien überhaupt und wird sehr oft verwendet. Sie gehört ins Grundvokabular jeder Informatikerin und jedes Programmierers. Eine ziemlich gute Strategie ist die binäre Suche. Und die geht so: Wenn die Zahl zwischen 1 und 100 liegen soll, dann fragst du zuerst, ob es 50 ist (die mittlere Zahl). Wahrscheinlich nicht, aber dein Gegenspieler wird sagen, ob die gesuchte Zahl kleiner oder grösser ist als 50. Und schon hast du die Anzahl der möglichen Zahlen halbiert! Sagen wir also, die gesuchte Zahl ist kleiner als 50, also zwischen 1 und 49. Nach welcher Zahl fragst du dann als nächstes? Du nimmst wieder die Mitte, nämlich 25. Wenn du dir bei der Strategie noch nicht ganz sicher bist, dann spiele das Ganze einmal für dich selber oder mit jemandem zusammen durch. Es hat wenig Sinn, das einzuprogrammieren, wenn du es nicht ganz verstehst. Nachdem du die Strategie kennst, zeige ich dir in den nächsten Abschnitten die Programmiertechniken, die du für das Spiel brauchst. Bei der binären Suche teilt der Computer die möglichen Zahlen in zwei Hälften ein und fragt dich dann, in welcher Hälfte deine Zahl liegt. Die»richtige«Hälfte wird dann wieder halbiert, die andere Hälfte weggelegt. Bei 100 möglichen Zahlen bleibt nach spätestens 7 Halbierungen nur noch eine Zahl übrig, bei 1000 Zahlen reichen 10 Halbierungen.

17 c 2013, Tobias Kohn Durchschnitte berechnen DURCHSCHNITTE BERECHNEN Worin du mit den Funktionen die wichtigste Programmiertechnik überhaupt kennenlernst. DER DURCHSCHNITT ZWEIER ZAHLEN Den Durchschnitt d zweier Zahlen a und b kannst du mit folgender Formel berechnen: d = a + b 2 In Scala kannst du zwei Zahlen in den Variablen a und b speichern und dann entsprechend den Durchschnitt berechnen: scala> var a = 7 a: Int = 7 scala> var b = 83 b: Int = 83 scala> (a + b) / 2 res30: Int = 45 GERECHNET WIRD SPÄTER Der Nachteil an dieser Methode: Sobald du eine Variable veränderst (a oder b) musst du die Formel wieder neu eingeben. Dabei kannst du in Scala auch eine Formel für später speichern und zwar so: scala> def d = (a + b) / 2 d: Int Scala hat den Durchschnitt jetzt noch nicht berechnet! Im Moment ist erst die Formel als d abgespeichert. Wenn du aber d eingibst, dann wird die Formel berechnet und du bekommst das Resultat: scala> d res31: Int = 45 Weil d die Formel enthält und keine Variable ist, wird die Formel jedes Mal mit den aktuellen Werten von a und b neu berechnet: scala> b = 26 b: Int = 26 scala> d res32: Int = 16

18 16 Zahlen raten c 2013, Tobias Kohn scala> a = 32 a: Int = 32 scala> d res33: Int = 29 Immer wenn du d eingibst, dann wird der Durchschnitt gemäss der Formel oben neu aus den beiden Werten von a und b berechnet. Wenn du die Formel (mit def) eingibst, musst du die tatsächlichen Zahlenwerte von a und b also noch nicht kennen (allerdings müssen die Variablen bereits definiert sein). In der Fachsprache des Programmierens ist d übrigens eine Funktion. Ähnlich wie Variablen spielen Funktionen eine sehr grosse Rolle. Es ist daher wichtig, dass du gut mit Funktionen umgehen kannst. FUNKTION VS. VARIABLE Das wesentliche Merkmal einer Funktion wie»durchschnitt«d ist, dass das Ergebnis immer erst dann berechnet wird, wenn der Wert gebraucht wird. Der Wert einer Variablen wird dagegen schon bei der Definition berechnet. In diesem Beispiel hier definieren wir wieder zuerst zwei Variablen a und b. Dann definieren wir den Durchschnitt einmal als Variable c und Der ganze Zauber einer Funktion liegt darin, dass die Formel erst einmal als Funktion d. Wenn wir jetzt den Wert von a verändern, dann später berechnet wird, meistens auch mehrfach mit unterschiedlichen siehst du den Unterschied zwischen der Variable c und der Funktion d. Zahlenwerten und Resulta- ten. scala> var a = 21 a: Int = 21 scala> var b = 43 b: Int = 43 scala> var c = (a + b) / 2 c: Int = 32 scala> def d = (a + b) / 2 d: Int scala> a = 28 res34: Int = 28 scala> c res35: Int = 32 scala> d res36: Int = 35

19 c 2013, Tobias Kohn Funktionen, die mit Variablen spielen 17 Die Variable c ist zwar aus a und b berechnet worden, enthält jetzt aber den festen Wert 32 unabhängig von a und b. Die Funktion d passt sich den aktuellen Werten von a und b an. Auch sehr grosse und umfangreiche Variablen sind letzlich nur einfache Boxen oder Container. Funktionen können hingegen selbständig sehr komplexe Berechnungen und Anweisungen ausführen und neue Zahlen berechnen. 2.3 FUNKTIONEN, DIE MIT VARIABLEN SPIELEN Worin du Funktionen programmierst, die den Inhalt von Variablen verändern und mehrere Berechnungen in einem Aufwasch erledigen. DAS ERGEBNIS IN EINER VARIABLEN SPEICHERN Nachdem du die Variablen a, b und c definiert hast, kannst du mit der Funktion mittelwert hier den Mittelwert der drei Zahlen in a, b und c berechnen. scala> def mittelwert = (a + b + c) / 3.0 mittelwert: Double Noch einmal: Das Wesen einer Funktion liegt darin, dass das Ergebnis jedes Mal neu berechnet wird, wenn irgendwo mittelwert vorkommt. Ich möchte diesen Mittelwert aber für später in der Variablen mw speichern. Das kann ich so machen:

20 18 Zahlen raten c 2013, Tobias Kohn scala> var mw = mittelwert mw: Double = 4.5 Eigentlich möchte ich aber, dass die Funktion ihr Ergebnis gleich selber in der Variablen mw speichert! Dazu definiere ich zuerst die Ergebnis- Variable: scala> var mw = 0.0 mw: Double = 0.0 Danach kommt die neue Funktion: Wenn eine Funktion kein Ergebnis hat, schreibt Scala jeweils Unit auf den Bildschirm. scala> def mittelwert = ( mw = (a + b + c) / 3.0 ) mittelwert: Unit Die äusseren Klammern helfen mit, das Ganze übersichtlich zu halten. Die Funktion berechnet jetzt nicht nur den Mittelwert, sie speichert ihn auch gleich in unserer Variablen mw. Dafür wird das Ergebnis nicht mehr auf den Bildschirm geschrieben. scala> mittelwert Es ist nicht immer sinnvoll oder besser, das Funktions-Ergebnis in einer Variablen zu speichern. Hin und wieder kann es aber eine gute Ergänzung sein. scala> mw res37: Double = 4.5 Du kannst jetzt also auch Funktionen programmieren, die ihr Ergebnis nicht mehr einfach auf den Bildschirm schreiben, sondern automatisch in einer Variablen speichern. VIER MITTELWERTE UND DAS SEMIKOLON Für zwei Zahlen a und b gibt es in der Mathematik verschiedene Mittelwerte, die je nach Anwendung sinnvoll sind. Dazu gehören das arithmetische Mittel, das geometrische Mittel, das harmonische Mittel und das quadratische Mittel: AM = a + b 2 GM = a b HM = 2 1 a + 1 b QM = a2 + b 2 2 Eine Liste mit Formeln oder Anweisungen {..;..;.. heisst in der Fachsprache ein Block. Du könntest für jedes Mittel eine Funktion schreiben, die den Mittelwert aus den zwei Variablen a und b berechnet. Statt dessen gehen wir einen anderen Weg und schreiben eine Funktion, die alle Mittelwerte auf einmal berechnet! Eine Funktion kann beliebig viele Formeln nacheinander berechnen! Die einzelnen Formeln trennst du dabei mit Semikola (Strichpunkten) ;. Zudem gehören alle Formeln zusammen in geschweifte Klammern. Und so sieht eine Funktion dann aus, die gleichzeitig das arithmetische und das geometrische Mittel berechnet:

21 c 2013, Tobias Kohn Funktionen, die mit Variablen spielen 19 scala> def mittel = { am = (a + b)/2.0; gm = sqrt(a*b) mittel: Unit Vergiss nicht, dafür sqrt aus dem Mathepaket zu importieren (s. S. 8) und zuerst alle benötigten Variablen zu definieren (als Double). Mit dem Semikolon kannst du übrigens immer Anweisungen und Rechnungen abtrennen. Die Variablen am und gm kannst du unabhängig von Funktionen zum Beispiel so definieren: scala> var am = 0.0; var gm = 0.0 am: Double = 0.0 gm: Double = 0.0 AUFGABEN 7. Erweitere die Funktion mittel so, dass sie tatsächlich alle vier Mittelwerte berechnet und in den entsprechenden Variablen am, gm, hm und qm speichert. 8. Was berechnet Scala bei der folgenden Eingabe? Wie kommt das Ergebnis von 12.0 zustande und welchen Wert hat x am Schluss? scala> var x = 7.5; x - 3; x += 1; x Mit dem Semikolon ; lassen sich einzelne Berechnungen und Anweisungen zusammenhängen, so dass sehr umfangreiche und komplexe Funktionen entstehen. Die letzte Berechnung in der Liste ist dafür verantwortlich, das Ergebnis der Funktion zurückzuliefern. Die einzelnen Berechnungen oder Anweisungen können entweder unabhängig voneinander sein, oder sich Zahlenwerte in Variablen verpackt gegenseitig zuschicken (dazu später mehr).

22 20 Zahlen raten c 2013, Tobias Kohn 2.4 DAS SPIEL PROGRAMMIEREN Worin du mit Hilfe von Funktionen endlich das Spiel programmierst. EINSCHACHTELN Für das Spiel brauchen wir zwei Variablen untgrenze und obgrenze. Am Anfang ist untgrenze = 1 und obgrenze = 100. Wenn du dann dem Computer sagst, dass die gesuchte Zahl kleiner als 50 ist, dann wird die obere Grenze auf 49 gesetzt (50 1). Indem immer entweder die untere oder die obere Grenze angepasst wird, wird der Zahlenbereich dazwischen immer kleiner und enthält am Schluss nur noch eine einzige Zahl. Das Programm beginnt also mit: scala> var untgrenze = 1 untgrenze: Int = 1 scala> var obgrenze = 100 obgrenze: Int = 100 Hinweis: Ein übliches Programm umfasst meistens sehr viele Variablen und Funktionen. Es ist deshalb wichtig, dass du den Variablen und Funktionen sinnvolle und selbsterklärende Namen gibst! Im Prinzip könntest du auch selber jeweils kleiner; ratemal eingeben. Wir programmierren den Computer aber so, dass er gleich selber nach jedem kleiner die DER ABLAUF Das Programm beginnt mit einem ratemal, wo der Computer das erste Mal raten soll. Danach gibst du kleiner oder groesser ein, um dem Computer Tipps zu geben. Nach jedem Tipp soll der Computer nochmals raten. Was genau passieren soll, ist ganz rechts aufgeführt. scala> ratemal res38: Int = 50 (untgrenze + obgrenze) / 2 scala> kleiner res39: Int = 25 nächste Zahl ratet und ausgibt. scala> groesser res40: Int = 37 obgrenze = 49; ratemal untgrenze = 26; ratemal scala> groesser res41: Int = 43 untgrenze = 38; ratemal Sobald die richtige Zahl erscheint, ist das Spiel fertig.

23 c 2013, Tobias Kohn Das Spiel programmieren 21 DIE DREI FUNKTIONEN Für den Ablauf brauchst du drei Funktionen: ratemal, kleiner und groesser. Die erste Funktion ratemal kannst du bereits selber einprogrammieren. Sie soll ja einfach den Durchschnitt zwischen untgrenze und obgrenze berechnen. Die zwei anderen Funktionen kleiner und groesser sollen entweder die obere oder die untere Grenze verändern und dann eine neue Zahl raten. Die zwei Funktionen kleiner und groesser müssen wissen, welche Zahl der Computer als letzte geraten hat: Schliesslich sollen sie die Grenzen an diese Ratezahl anpassen. Deshalb führen wir noch eine dritte Variable ratezahl ein, in der wir den aktuellen Wert der geratenen Zahl speichern. scala> var ratezahl = 0 ratezahl: Int = 0 Die Funktion ratemal ist dafür verantwortlich, den Durchschnittswert in ratezahl zu speichern. Nur: Wenn du das so machst, wie auf Seite 17 gezeigt, dann schreibt ratezahl die geratene Zahl nicht mehr auf den Bildschirm. Dem helfen wir mit einem kleinen Trick ab: Wenn du in Scala eine grössere Funktion eingibst, ist es oft sinnvoll, die einzelnen Anweisungen oder Berechnungen wie hier auf separate Zeilen zu verteilen. Scala merkt an den geschweiften Klammern selbständig, wann die Funktion fertig ist und verlängert bis dahin die Eingabe mit den senkrechten Strichen. scala> def ratemal = { ratezahl = (obgrenze + untgrenze) / 2; ratezahl ratemal: Int Eigentlich ist ratezahl keine wirkliche»berechnung«. Damit wird lediglich der Inhalt der Variablen ratezahl zurückgegeben genau das, was wir hier ja auch wollen! scala> ratemal res42: Int = 50 scala> ratezahl res43: Int = 50 Wenn du kleiner eingibst, dann muss die obere Grenze angepasst werden. Anschliessend soll die Funktion kleiner gerade noch eine neue Zahl raten. scala> def kleiner = { obgrenze = ratezahl-1; ratemal kleiner: Int Die Funktion groesser kannst du inzwischen auch ohne Anleitung einprogrammieren. Schliesslich sieht sie fast gleich aus wie groesser. Danach hast du dein erstes kleines Spiel einprogrammiert: Herzliche Gratulation und viel Spass damit!

24 22 Zahlen raten c 2013, Tobias Kohn Wichtige Punkte Eine Funktion ist eine Liste von Anweisungen und Berechnungen. Die einzelnen Anweisungen werden durch Semikola getrennt und in geschweifte Klammern gesetzt. Natürlich kann eine Funktion auch nur aus einer Berechnung bestehen. Dann brauchst du weder Semikolon noch geschweifte Klammern. Der grosse Unterschied zwischen einer Funktion und einer Variablen ist der, dass die Funktion erst berechnet wird, wenn sie im Code aufgerufen wird. Die Werte von Variablen werden immer schon bei ihrer Definition oder Zuweisung berechnet. Bei der binären Suche teilst du den Suchbereich immer in zwei Hälften ein und entscheidest dann, in welcher Hälfte die gesuchte Zahl liegen muss. AUFGABEN 9. Programmiere das Spiel selber fertig und probiere es aus. Für welche Zahlen braucht der Computer am längsten, um sie zu erraten? 10. Erweitere dein Spiel um eine Funktion neuesspiel, die die Variablen untgrenze und obgrenze zurücksetzt. 11. Warum ist es bei diesem Spiel sinnvoll, dass der Computer immer mit Integern arbeitet und nicht mit Double? Welche Zahl würde der Computer als erste raten, wenn das Spiel mit Double-Werten programmiert wäre? 12. Ändere das Spiel so ab, dass anstelle des arithmetischen Mittels z. B. das geometrische Mittel verwendet wird, um die nächste Zahl zu raten. Braucht der Computer dann länger, um deine Zahlen zu erraten oder hat er sie schneller? 13. * Ändere das Spiel so ab, dass der Computer nicht die Mitte zwischen der unteren und der oberen Grenze nimmt, sondern eine zufällige Zahl aus diesem Bereich! Achte darauf, dass die zufällige Zahl wirklich aus dem angegebenen Bereich stammt.

25 c 2013, Tobias Kohn Das Spiel programmieren Die Variable x enthält den Integer-Wert 3. Welche Funktion(en) haben das Ergebnis 10? a. def f = 4*x - 2 b. def f = { x -= 1; x + 8 c. def f = x+4; 10 d. def f = (x/2)* Wenn du versuchst, die Variable p wie folgt zu definieren, dann gibt Scala einen Fehler aus, weil du durch Null dividierst. scala> var p = 1 / 0 java.lang.arithmeticexception: / by zero Nun wird eine Funktion q definiert, die eine Division durch Null enthält: scala> def q = 0 / 0 Was passiert? a. Scala gibt wieder den gleichen Fehler aus wie zuvor. b. c. Die Funktion q lässt sich definieren, weil das Ergebnis der Funktion erst später berechnet wird. Die Funktion q lässt sich definieren, weil Scala das 0/0 zu 1 kürzt. d. Die Funktion q lässt sich nicht definieren, weil Scala nicht weiss, ob das Ergebnis ein Integer oder ein Double ist. 7. Wie viele Schritte (Halbierungen) mit der binären Suche brauchst du höchstens, um eine Zahl aus dem Bereich zwischen 1 und zu finden? a. 15 b. 20 c. 30 d. über 100

26 24 Zahlen raten c 2013, Tobias Kohn

27 k a p i t e l d r e i ZAHLEN RATEN II: DIE REVANCHE Lernziele Wie verwendest du Parameter in einer Funktion? Was ist der Unterschied zwischen einem Parameter und einer Variable? Wie vergleicht Scala zwei Werte und wann wird eine bedingte Anweisung ausgeführt? Was ist der Unterschied zwischen einfachen und doppelten Gleichheitszeichen? Mit welchem Befehl schreibt Scala etwas auf den Bildschirm? Welche Rolle spielen Gänsefüsschen? Wie erzeugt Scala seine Zufallszahlen? Warum ist das Teilen mit Rest beim Programmieren so wichtig? EINFÜHRUNG In diesem Kapitel werden die Rollen vertauscht. Du sollst hier die geheime Zahl des Computers erraten. Dafür brauchst du eine neue Programmiertechnik: Der Computer muss Entscheidungen treffen können. Nicht immer soll er den ganzen Code ausführen. Bevor du das zweite Spiel programmierst und noch einmal gegen den Computer spielen kannst, lernst du wieder die Programmiertechniken kennen, die du dafür brauchst. Insgesamt sind das drei Techniken: Etwas auf den Bildschirm schreiben, Funktionen mit Parametern füttern und den Computer Entscheidungen treffen lassen.

28 26 Zahlen raten II:Die Revanche c 2013, Tobias Kohn 3.1 SCALA LERNT SCHREIBEN Worin Scala etwas buchstabengetreu auf den Bildschirm schreibt. Zum Ratespiel gehört, dass dir der Computer Tipps gibt. Wenn deine Zahl zu klein war, dann soll er»zu klein«auf den Bildschirm schreiben. Der Befehl, um einen Text auf den Bildschirm zu schreiben, heisst println (das ist eine Kurzform für»print lineeine Zeile ausdrucken«) und so funktioniert es: scala> println("die Zahl ist zu klein.") Die Zahl ist zu klein. Beachte die Gänsefüsschen! Immer wenn du in Scala mit Text arbeitest, dann gehört dieser in solche (doppelten) Gänsefüsschen wie im Beispiel. Dazwischen kannst du aber alles schreiben, was du möchtest (ausser anderen Gänsefüsschen). GÄNSEFÜSSCHEN Wozu braucht es diese Gänsefüsschen eigentlich? Was passiert, wenn du sie einmal weglässt? Probiere es ruhig aus! scala> println(hallo) <console>:8: error: not found: value Hallo Ohne die Gänsefüsschen glaubt Scala,»Hallo«sei eine Variable und reklamiert, weil es diese Variable nicht findet. Wenn Scala einen Text schreiben soll, dann gehört der Text immer zwischen Gänsefüsschen. Zum Beispiel "Scala".

29 c 2013, Tobias Kohn Funktionen füttern FUNKTIONEN FÜTTERN Worin du den Funktionen über Parameter Werte mitgibst. EINE NEUE MÖGLICHKEIT Im letzten Kapitel hast du eine Funktion programmiert, um den Durchschnitt zweier Zahlen a und b zu berechnen. Bevor du aber den Durchschnitt mit der Funktion effektiv berechnet konntest, musstest du die richtigen Werte in den Variablen speichern. Jetzt geht es darum, das in einem Aufwasch zu erledigen. Das hier ist die alte Variante aus dem letzten Kapitel: scala> var a = 7 a: Int = 7 scala> var b = 83 b: Int = 83 scala> def d = (a + b) / 2 d: Int Damit die Funktion ihre Aufgabe erledigen kann, braucht sie erst einmal Eingabewerte. Parameter sind eine besonders praktische Möglichkeit, diese (Zahlen-)Werte an die Funktion zu übergeben. scala> d res44: Int = 45 Und so lässt sich das einfacher und eleganter machen: scala> def d(a: Int, b: Int) = (a + b) / 2 d: (a: Int, b: Int)Int scala> d(7, 83) res45: Int = 45 In dieser neuen Möglichkeit sind a und b Parameter. Im Gegensatz zu einer Variablen gibst du den Wert eines Parameters genau dann an, wenn du die Funktion aufrufst und damit die Berechnung startest. Du hast Parameter auch bereits früher verwendet. Zum Beispiel bei der Funktion math.sqrt zum Berechnen von Wurzeln. Im nächsten Beispiel übergebe ich 2 als Parameter an die Funktion, damit sie dann die Wurzel davon berechnen kann: scala> math.sqrt(2) res46: Double =

30 28 Zahlen raten II:Die Revanche c 2013, Tobias Kohn PARAMETER DEFINIEREN Fast alle Funktionen brauchen Eingabewerte für ihre Berechnungen. Wenn du die Funktion definierst, kennst du diese Werte natürlich noch nicht. Du gibst in Klammern an, welche»variablen«beim Funktionsaufruf die Eingabewerte sind und automatisch durch Zahlen ersetzt werden sollen: Das sind dann die Parameter. Wie auch bei den Variablen muss Scala bei den Parametern wissen, von welchem Typ sie sind. Möchtest du bei deiner Funktion mit Integer oder Double arbeiten? Diesen Typ musst du immer zwingend mit einem Doppelpunkt angeben. Wenn x ein Parameter ist, dann werden später alle x in der Funktion durch Zahlenwerte ersetzt. Eine Funktion»quadrat«, die eine Zahl x quadriert, sieht so aus: scala> def quadrat(x: Double) = x * x quadrat: (x: Double)Double Anschliessend kannst du die Funktion verwenden und gibst in Klammern jeweils den Wert für x an. Dass der Parameter x heisst, spielt hier keine Rolle mehr das musst du nicht wissen, um die Funktion zu verwenden. scala> quadrat(3.0) res47: Double = 9.0 Für die Berechnung ersetzt Scala alle x in der Funktion quadrat automatisch durch 3.0. In Variablen speicherst du Werte für eine längere Zeit und kannst sie jederzeit wieder abrufen. Eine Funktion kann auch auf diese Variablen zugreifen und die Zahlen darin verwenden oder sogar verändern. Parameter sind dagegen nicht dazu da, Werte abzuspeichern. Vielmehr geht es darum, der Funktion eine Zahl für die Berechnung zu geben.

31 c 2013, Tobias Kohn Funktionen füttern 29 Beim Aufrufen einer Funktion musst du zwingend für alle Parameter Zahlenwerte angeben! Wenn du zum Beispiel die Quadrat-Funktion von oben ohne Zahl aufrufst, dann beschwert sich Scala. scala> quadrat <console>:9: error: missing arguments for method quadrat in object $iw; Mit»method«meint Scala hier dasselbe wie wir mit»funktion«. Zwischen Parametern und Variablen gibt es zwei wesentliche Unterschiede: (1) Parameter lassen sich nicht verändern, Variablen aber schon. (2) Variablen speichern Werte für später; Parameter sind Platzhalter und geben an, wo später die wirklichen Eingabewerte eingefügt werden sollen. PARAMETER UND VARIABLEN Auf den ersten Blick sehen Parameter fast gleich aus wie Variablen. Es gibt aber einen wesentlichen Unterschied: Ein Parameter speichert die Zahl nicht ab, sondern fügt sie lediglich in die»formel«ein. Sobald die Funktion fertig ist, existieren auch die Parameter nicht mehr. Das Beispiel hier zeigt dir, dass ein Parameter keinen Einfluss auf Variablen hat. Nicht einmal, wenn die Variable genau gleich heisst wie der Parameter. scala> var a = 1 a: Int = 1 Die Variable bekommt hier den Wert 1. scala> def f(a: Int) = 2 * a f: (a: Int)Int Hier ist a nur ein Parameter und hat keinen Wert. scala> a = 5 res48: Int = 5 scala> f(9) res49: Int = 18 Die Variable wird auf 5 gesetzt. In der Funktion wird das a durch 9 ersetzt und 2*9 berechnet. scala> a res50: Int = 5 Die Variable a ist immer noch 5. In einem Parameter kannst du keine Zahlen speichern. Das nächste Beispiel zeigt dir, dass eine Funktion zwar Variablen verändern kann, aber keine Parameter. scala> var a = 1 a: Int = 1 Die Variable a enthält den Wert 1. scala> def f(b: Int) = { a = b * 2 f: (b:int)unit Die Funktion f speichert das Doppelte von b in der Variablen a. scala> def g(b: Int) = { b = a * 2 <console>:8: error: reassignment to val Das funktioniert nicht: b lässt sich nicht verändern. Scala reklamiert.

32 30 Zahlen raten II:Die Revanche c 2013, Tobias Kohn Übrigens: Der Fehler»reassignment to val«bedeutet, dass Scala einen Wert (engl.»value«) nicht neu zuweisen kann. In anderen Worten: In einer Zahl lässt sich nichts speichern (das b in der Funktion g ist ja keine wirkliche Variable und wird später automatisch durch eine Zahl ersetzt). AUFGABEN 14. Schreibe eine Funktion für x 3, die folgende Ausgabe liefert: scala> hochdrei(4) res51: Int = 64 Achte darauf, dass das Ergebnis ein Integer-Wert ist. 15. Programmiere eine Funktion kreis, die aus dem Kreisradius r den Flächeninhalt des Kreises berechnet (A = r 2 π). 16. Zurück zum Pythagoras (a 2 + b 2 = c 2 ): Programmiere eine Funktion pyth, die aus den zwei Kathetenlängen a und b die Hypotenusenlänge c berechnet. 17. Quadratische Gleichungen wie x 2 5x + 4 = 0 lassen sich nicht mehr wirklich nach x auflösen. Es gibt aber eine Formel, um die Lösungen solcher Gleichungen zu berechnen: ax 2 + bx + c = 0 x 1 = b + b 2 4ac 2a Im Beispiel oben wäre also a = 1, b = 5 und c = 4. Die erste Lösung x 1 ist damit 4 (meistens gibt es noch eine zweite Lösung). Programmiere eine Funktion, die aus den drei Parametern a, b und c die erste Lösung einer quadratischen Gleichung berechnet. 18. Neben der Anweisung println gibt es noch eine ähnliche Anweisung print. Finde den Unterschied heraus, zum Beispiel indem du folgendes ausprobierst und veränderst: scala> println("hallo"); print("scala") 19. * Schreibe eine Funktion, die eine Addition mit Ergebnis auf den Bildschirm schreibt: scala> addition(3, 4) = 7 Dazu brauchst du mehrere sinnvoll zusammengesetzte print Anweisungen.

33 c 2013, Tobias Kohn Vergleichen und Entscheiden VERGLEICHEN UND ENTSCHEIDEN Worin Scala Werte vergleicht und eine Anweisung nur ausführen darf, wenn die richtige Bedingung erfüllt ist. NUR AUSFÜHREN, FALLS... Bedingungen brauchst du immer dann, wenn der Computer auf deine Eingaben reagieren soll. Falls deine Zahl z. B. grösser ist als 100, dann (und nur dann) soll er schreiben»die Zahl ist zu gross.«in Scala: scala> if (zahl > 100) println("die Zahl ist zu gross.") Hinter dem if steht zuerst in Klammern, welche Bedingung erfüllt sein muss. Nach der Bedingung folgt dann die Anweisung, die nur ausgeführt wird, wenn die Bedingung erfüllt ist. VERGLEICHE Bei den Vergleichen gibt es eine Besonderheit: Das doppelte Gleichheitszeichen. Damit prüfst du, ob eine Variable einen bestimmten Wert enthält oder zwei Variablen den gleichen Wert enthalten. scala> if (x == 3) println("x ist 3") scala> if (x == y) println("x und y sind gleich") Scala unterscheidet strikt zwischen Zuweisungen (=, +=, -=), die den Wert einer Variable verändern und Vergleichen (==,!=, <, >, <=, >=), die Werte miteinander vergleichen. Wozu braucht es für diese Vergleiche ein doppeltes Gleichheitszeichen? Weil ein einzelnes Gleichheitszeichen (z. B. x = 3) einen neuen Wert in der Variable speichert, anstatt zu vergleichen. Schliesslich kannst du auch prüfen, ob eine Variable gerade nicht einen bestimmten Wert enthält. Dafür verwendest du!= wie im folgenden Beispiel: scala> if (x!= 3) println("x ist nicht 3") Die if-bedingung stellt sicher, dass der Computer die Anweisung dahinter nur ausführt, wenn die angegebene Bedingung auch wirklich erfüllt ist. Meistens vergleichst du dazu die Werte, die in Variablen gespeichert sind.

34 32 Zahlen raten II:Die Revanche c 2013, Tobias Kohn TEILBARKEIT Erinnerst du dich noch an die Division mit Rest? Mit dem Operator % berechnet Scala den Rest bei einer Division. Zum Beispiel: scala> 30 % 7 res52: Int = 2 scala> 18 % 5 res53: Int = 3 scala> 45 % 9 res54: Int = 0 Immer wenn eine Zahl z. B. durch 9 teilbar ist, dann ist der Divisionsrest Null. Damit kannst du eine Zahl auf ihre Teilbarkeit hin überprüfen. Ob die Variable zahl einen Wert enthält, der durch 3 teilbar ist, prüfst du so: scala> if (zahl % 3 == 0) println("durch 3 teilbar.") Wir greifen die Teilbarkeit und insbesondere das Teilen mit Rest immer wieder auf. AUFGABEN 20. Schreibe eine Funktion evenodd, die prüft, ob eine ganze Zahl x gerade oder ungerade ist und das entsprechende Ergebnis auf den Bildschirm schreibt (»even«ist Englisch für»gerade«und»odd«heisst hier»ungerade«). scala> evenodd(785) ungerade 21. Hin und wieder muss der Wert in einer Variable x sicher im Bereich zwischen 10 und 99 liegen. Schreibe eine Funktion, die prüft, ob x zu gross oder zu klein ist und den Wert von x gegebenenfalls korrigiert. Ist der Wert zu klein, wird er auf 10 gesetzt, ist er zu gross auf 99. scala> var x = 5 x: Int = 5 scala> correctx scala> x res55: Int = 10

35 c 2013, Tobias Kohn Das zweite Spiel: Rollentausch DAS ZWEITE SPIEL: ROLLENTAUSCH Worin du mit dem Computer die Rollen tauschst und selber eine Zahl errätst. Für das neue Spiel brauchst du zwei Funktionen. Mit neuesspiel startest du eine neue Runde und mit probiere probierst du jeweils eine Zahl aus. Das fertige Spiel wird dann so aussehen: scala> neuesspiel scala> probiere(50) grösser scala> probiere(75) kleiner scala> super! probiere(61) EINE ZAHL AUSSUCHEN Wenn du neuesspiel eingibst, soll sich der Computer eine neue Zahl aussuchen, und zwar wieder aus dem Bereich 1 bis 100. Dazu verwendest du den Zufallsgenerator, den du schon von der Seite 9 her kennst. Diese Zahl speichert der Computer dann in der Variable geheimzahl. Das machst du so: scala> var geheimzahl = 0 geheimzahl: Int = 0 scala> var zufall = util.random zufall: util.random.type = scala.util.random$@386f43d scala> def neuesspiel = { geheimzahl = zufall.nextint(100) + 1 neuesspiel: Unit Zuerst speichern wir den Zufallsgenerator in der Variablen zufall. Mit nextint(100) zieht der Computer eine Zufallszahl zwischen 0 und 99. Wir zählen eins dazu, damit die Zahl im Bereich zwischen 1 und 100 liegt. Damit hat sicher der Computer eine Zahl ausgesucht und wir können uns dem Raten widmen.

36 34 Zahlen raten II:Die Revanche c 2013, Tobias Kohn EINE ZAHL PRÜFEN Mit der Funktion probiere probierst du, ob deine Zahl richtig, zu gross oder zu klein ist. Deine geratene Zahl gibst du als Parameter mit. Das sieht dann etwa so aus: scala> def probiere(zahl: Int) = { if (zahl > geheimzahl) println("zu gross") probiere: (zahl: Int)Unit scala> probiere(204) zu gross Diese Funktion ist natürlich noch nicht fertig! Sie prüft erst, ob deine Zahl zu gross ist. Es ist jetzt deine Aufgabe, diese Funktion fertig auszubauen, so dass sie je nachdem»super!«,»gewonnen!«,»zu klein«oder etwas anderes auf den Bildschirm schreibt. AUFGABEN 22. Vervollständige die Funktion probiere, so dass du ein fertiges Spiel hast. Probiere das Spiel auch aus: Wie schnell kannst du die Zahlen des Computers erraten? 23. Noch einmal quadratische Gleichungen (siehe Seite 30): Am Ausdruck D = b 2 4ac kannst du ablesen, wie viele Lösungen die Gleichung hat. Für D < 0 hat die Gleichung keine Lösung, für D = 0 hat sie eine Lösung und für D > 0 hat sie zwei Lösungen. Schreibe eine Funktion anzahllsg(a: Int, b: Int, c: Int), die auf den Bildschirm schreibt, wie viele Lösungen die quadratische Gleichung ax 2 + bx + c = 0 hat.

37 c 2013, Tobias Kohn Flip-Flop FLIP-FLOP Worin Variablen und Funktionen immer zwischen den gleichen Werten hin- und herwechseln. EIN- UND AUSSCHALTEN Immer einmal wieder brauchst du eine Variable, die zwischen den zwei Werten 0 und 1 hin- und herwechselt. Mit einer Idee aus der Trickkiste von Programmierern lässt sich das sehr einfach umsetzen. Variablen, die nur zwei mögliche Zustände haben, heissen oft auch Flags. Die Funktion switch soll jeweils den Wert der Variablen flipflop wechseln. Und so geht s: scala> var flipflop = 0 flipflop: Int = 0 scala> def switch = { flipflop = 1 - flipflop switch: Unit Wenn die Variable flipflop den Wert 0 enthält, dann ist 1 0 = 1 und entsprechend wird flipflop auf 1 gesetzt. Hat flipflop den Wert 1, dann ist 1 1 = 0 und flipflop wird auf 0 gesetzt. Vielleicht soll die Funktion switch den aktuellen Zustand der Variable flipflop gerade zurückliefern. Dann ergänzen wir die Funktion entsprechend: scala> def switch = { flipflop = 1 - flipflop; flipflop switch: Int Mit der Uhr kennst du bereits Fälle, wo nach 12 wieder 1 kommt, bzw. wo es nach 59 wieder bei 0 beginnt. DREI ZUSTÄNDE Leider gibt es keinen so schönen Trick mehr, wenn eine Variable immer zwischen drei Zuständen wechseln soll. Zum Beispiel so: 0, 1, 2, 0, 1, 2,... (Computer beginnen beim Zählen immer mit Null). Trotzdem zeige ich dir auch dafür eine Funktion. scala> var tictactoc = 0 tictactoc: Int = 0 scala> def switch = { tictactoc += 1; if (tictactoc > 2) tictactoc = 0 switch: Unit

38 36 Zahlen raten II:Die Revanche c 2013, Tobias Kohn Ein zweiter Weg führt über die Division mit Rest (auch bekannt als»modulo«-rechnen): scala> def switch = { tictactoc = (tictactoc + 1) % 3 switch: Unit Was passiert hier? Der Wert in der Variable tictactoc wird zuerst um 1 erhöht. Das Resultat wird dann durch 3 geteilt und der Rest dieser Division wieder in der Variable tictactoc gespeichert. AUFGABEN 24. Erweitere die Funktion switch so, dass sie nicht den Wert der Variablen flipflop zurückgibt, sondern»ein«oder»aus«auf den Bildschirm schreibt. 25. Schreibe eine Funktion nextnumber, die nacheinander alle natürlichen Zahlen zurückgibt. Beim ersten Aufruf von nextnumber soll das Resultat 1 sein, beim zweiten Aufruf 2 usw. 26. Schreibe eine Funktion countdown, die von 10 an zurück bis auf 0 zählt und dann wieder bei 10 beginnt. 27. Programmiere eine Funktion teile(a: Int, b: Int), die a durch b teilt und das Ergebnis mit Rest ausgibt. scala> teile(15, 6) 15/6 = 2 Rest * Schreibe eine Funktion, die eine Sekundenzahl in Tage, Stunden, Minuten und Sekunden umrechnet. Es gibt erstaunlich viele Anwendungen für das An-Aus-Prinzip oder für Variablen, die z. B. nach 59 wieder bei Null beginnen (Uhren).

39 c 2013, Tobias Kohn Dem Zufall in die Karten schauen DEM ZUFALL IN DIE KARTEN SCHAUEN Worin du deine eigenen Zufallszahlen erzeugst. DEN ZUFALL BERECHNEN Computer können gar keine echten Zufallszahlen erzeugen! Die Zahlen, die dir Scala über util.random (vgl. Seite 9) zurückgibt, sind sorgfältig berechnet, um wie Zufallszahlen auszusehen. Solche Pseudo- Zufallszahlen kannst du auch selber machen und in diesem Abschnitt zeige ich dir, wie. Das Geheimnis liegt im Teilen mit Rest. Du kennst sicher noch die Siebener-Reihe aus dem kleinen Einmaleins: 7, 14, 21, 35, 42, 49, 56, 63, 70,... So berechnete Zufallszahlen haben echten Zufallszahlen gegenüber einen Vorteil: Es kommen garantiert alle Zahlen im Bereich gleich häufig und mindestens einmal vor. Der»echte Zufall«tendiert dazu, x-mal hintereinander die gleiche Zahl zu erzeugen und lässt dafür andere Zahlen ganz aus. Künstliche Zufallszahlen sind also besser verteilt als der echte Zufall. Soweit sind die Zahlen schön regelmässig. Jetzt teilen wir jede Zahl durch 10 und nehmen den Rest davon (im Endeffekt nehmen wir also immer die Einerziffern): 7, 4, 1, 5, 2, 9, 6, 3, 0,... Diese Zahlen hier wirken ziemlich zufällig und doch kommt jede Zahl zwischen 0 und 9 genau einmal vor. Und schon haben wir zehn Pseudo- Zufallszahlen erzeugt. Falls du aber weitergehen würdest, würden wieder die gleichen Zahlen in der gleichen Reihenfolge vorkommen. An die Stelle der Siebenerreihe tritt häufig eine leicht kompliziertere Folge, z. B.: 0, 1, 62, 3 783, ,... ( = ) Rechts ist in Klammern ein Beispiel angegeben, wie die jeweils nächste Zahl berechnet wird. Für die Zufallszahlen nimmst du jetzt jeweils die letzten zwei Ziffern. Und so sieht das in Scala aus: scala> var zufallszahl = 0 zufallszahl: Int = 0 scala> def zufall = { zufallszahl = (zufallszahl * ) % 100; zufallszahl zufall: Int Diese Folge geht übrigens auch alle Zahlen von 0 bis 99 genau einmal durch, bevor sie wieder von Vorne beginnt.

40 38 Zahlen raten II:Die Revanche c 2013, Tobias Kohn SCALAS ZUFALLSZAHLEN-GENERATOR Du kennst bereits Scalas Zufallszahlen-Generator util.random. Ich zeige dir hier, dass auch diese Zufallszahlen nach einem festen Muster berechnet werden. Dazu legst wieder einmal zuerst eine Variable mit dem Zufallszahlen-Generator an: scala> var zufall = util.random zufall: util.random.type = scala.util.random$@6dbb28b4 Dieser Generator hat intern eine versteckte Variable zufallszahl. Mit setseed kannst du den Wert dieser unsichtbaren Variable setzen. Danach erzeugst du mit nextint wie üblich einige Zufallszahlen. scala> zufall.setseed(21) scala> zufall.nextint(30) res56: Int = 8 scala> zufall.nextint(30) res57: Int = 24 scala> zufall.nextint(30) res58: Int = 10 Der Computer würfelt nicht! Auch wenn die Zahlen aussehen wie Zufallszahlen: In Wahrheit sind sie sorgfältig berechnet. Wenn du jetzt mit setseed den Wert der internen Zufallszahl wieder auf 21 zurücksetzst, dann erscheinen bei nextint wiederum die genau gleichen Zahlen! Ein weiteres Experiment, das du machen kannst: Setze die interne Zufallszahl wieder mit zufall.setseed(0) auf Null und erzeuge dann mit zufall.nextint(100) einige Zufallszahlen zwischen 0 und 99. Danach verwendest du noch einmal zufall.setseed(0) und erzeugst Zufallszahlen mit zufall.nextint(10). Fällt dir etwas auf? Übrigens: Scalas Zufallszahlen-Generator ist so programmiert, dass er einige Milliarden Zahlen erzeugen kann, bevor er sich wiederholt. Mit nextint ohne Parameter zeigt dir Scalas seine»internen«zahlen an. scala> zufall.setseed(0) scala> zufall.nextint res59: Int = scala> zufall.nextint res60: Int = scala> zufall.nextint res61: Int =

41 c 2013, Tobias Kohn Dem Zufall in die Karten schauen 39 AUFGABEN 29. Bei Scalas Funktion nextint kannst du in Klammern angeben, in welchem Bereich die Zufallszahl liegen soll. Programmiere selber eine Funktion nextrandomint, bei der du mit einem Parameter angeben kannst, in welchem Bereich die Zufallszahl liegen soll. Wichtige Punkte Mit den Anweisungen print und println schreibt Scala etwas auf den Bildschirm. Dabei springt println nach der Ausgabe auf die nächste Zeile, print aber nicht. Wenn du mit print Text ausgibst, dann musst du den Text in Gänsefüsschen setzen. Parameter sind Platzhalter in Funktionen. Wenn du eine Funktion aufrufst, dann musst du für alle Parameter in Klammern konkrete Werte angeben. Scala setzt dann automatisch deine Werte in die Funktion ein. Im Unterschied zu Variablen können Parameter keine Werte speichern und ihren Wert nicht ändern. Mit einer if-bedingung formulierst du eine Bedingung, die erfüllt sein muss, bevor der Code dahinter ausgeführt werden darf. Die Bedingungen sind meistens Vergleiche: Du prüfst, welchen Wert eine Variable hat. Zum Prüfen auf Gleichheit brauchst du ein doppeltes Gleichheitszeichen ==. Das einfache Gleichheitszeichen vergleicht nicht, sondern speichert einen neuen Wert in einer Variablen. Für Vergleiche kannst du die folgenden Relationen verwenden: == (gleich),!= (ungleich), < (kleiner), > (grösser), <= (kleiner oder gleich), >= (grösser oder gleich). Zufallszahlen im Computer sind nie wirklich zufällig, sondern immer berechnet. Meistens mit einer Formel, die auf dem Teilen mit Rest basiert. Man speicht daher oft auch von Pseudo-Zufallszahlen.

42 40 Zahlen raten II:Die Revanche c 2013, Tobias Kohn 8. Was schreibt die Anweisung print(3 + 4) auf den Bildschirm? a b. 7 c. 34 d. Gar Nichts: print braucht immer Gänsefüsschen. 9. In der folgenden Codesequenz wird eine Variable x und eine Funktion f definiert. scala> var x = 2.5 x: Double = 2.5 scala> def f(x: Int) = { println(x) f: (x: Int)Unit Was schreibt Scala beim Aufruf f(3) auf den Bildschirm? a. Den Buchstaben x. b. Den Wert der Variable x, also 2.5. c. Den angegebenen Parameter-Wert, also 3. d. Die beiden Werte der Variablen und des Parameters, also 2.5 und Welche Aussagen sind im Zusammenhang mit Scalas Zufallszahlengenerator richtig? a. nextint(10) wiederholt sich nach 10 Zahlen und beginnt wieder von Vorne. b. c. Weil nextint(x) auf dem Teilen mit Rest basiert, ist die erzeugte Zufallszahl immer kleiner als x. Die Pseudo-Zufallszahlen von Scala sind besser verteilt als der echte Zufall. d. Scalas Zufallszahlen basieren auf der Siebenerreihe.

43 k a p i t e l v i e r CAESARS VERSCHLÜSSELUNG Lernziele Welchen Datentyp hat Text bzw. haben einzelne Buchstaben? Was ist der Unterschied zwischen Gänsefüsschen und Apostrophen? Wie kannst du einen Wert von einem Datentyp in einen anderen Datentyp umwandeln? Wie wiederholst du eine Anweisung für alle Buchstaben in einem Text oder alle Zahlen in einem Bereich? 4.1 BUCHSTABEN ERSETZEN Worin Buchstaben Plätze tauschen und damit die Nachricht verstecken. EINFÜHRUNG Schon sehr lange haben sich Erfinder und Wissenschaftler darum bemüht, eine Maschine zum Rechnen zu bauen: Einen Taschenrechner oder Computer. Die ersten Computer wurden dann aber mehrheitlich nicht für die Mathematik gebaut, sondern um geheime Nachrichten zu entschlüsseln. Die Ver- und Entschlüsselung von Texten hat also bei der Geburt der Computer Pate gestanden und spielt auch heute noch eine enorm wichtige Rolle. Grund genug, dass wir uns in diesem Kapitel ebenfalls mit der Verschlüsselung beschäftigen. Das Verfahren, mit dem du in diesem Kapitel deine Texte verschlüsselst, ist Jahrtausende alt und nicht besonders sicher. Es geht mir hier auch nicht darum, dich zum Sicherheitsexperten zu machen, sondern darum, die Prinzipien aufzuzeigen, wie du in Scala mit Text arbeiten kannst.

44 42 Caesars Verschlüsselung c 2013, Tobias Kohn DAS ALPHABET ROTIEREN Die Verschlüsselung, die Caesar verwendet hat, ist die wohl denkbar einfachste überhaupt. Jeder Buchstabe wird im Alphabet um drei Plätze nach rechts geschoben. Somit wird das A zu einem D, das B zu einem E und das X wird wiederum zu einem A. Anstatt alle Buchstaben um 3 Plätze zu verschieben, lassen sie sich genauso gut um 1 oder 14 Plätze verschieben. Im Prinzip eignet sich jede Zahl von 1 bis 25 dazu. Die Zahl, um die du die Buchstaben verschiebst, heisst der Schlüssel. W Z X A Y B Z C A D B E C F D G E H V F I Y U X T W S V R U Q T P S O R N Q M P L O K N H K I L J M G J Eine Codierscheibe für die Caesar- Verschlüsselung. Indem du die innere Scheibe drehst, kannst du verschiedene Schlüssel einstellen. In diesem Fall hier (der Schlüssel ist 3) würde aus dem A ein D (A D) und aus dem J ein M etc. Um die Nachricht wieder zu entschlüsseln, verschiebst du die Buchstaben einfach wieder um die richtige Anzahl Plätze zurück. SICHERHEIT Warum ist diese Caesar-Verschlüsselung sehr unsicher? Weil es nur gerade 25 mögliche Schlüssel gibt. Wenn du eine verschlüsselte Nachricht ohne den Schlüssel hast, dann kannst du den Text auch von Hand mit Durchprobieren relativ schnell wieder entschlüsseln. Mit einem Computer dauert das weit weniger als eine Sekunde. Bei Caesar hat das Verfahren wahrscheinlich nur deshalb funktioniert, weil kaum jemand lesen konnte und die Idee noch neu war. DAS ZIEL DES KAPITELS Im Verlaufe dieses Kapitels schreibst du eine Funktion, mit der du einen beliebigen Text mit dem Caesar-Verfahren ver- und entschlüsseln kannst. Dazu brauchst du zwei wichtige Prinzipien: Zum einen lernst du, wie du in Scala mit Text und Buchstaben arbeiten kannst. Zum anderen soll Scala die gleiche Verschlüsselung für alle Buchstaben in einem Text automatisch wiederholen. Das erreichst du mit einer Schleife. Um mit den Buchstaben zu spielen brauchst du relativ viel Hintergrundwissen darüber, wie Scala intern arbeitet und welche Rolle Datentypen dabei spielen. Deshalb enthält dieses Kapitel etwas mehr Theorie als die bisherigen Kapitel.

45 c 2013, Tobias Kohn Wörter und Sätze speichern WÖRTER UND SÄTZE SPEICHERN Worin Gänsefüsschen und Apostrophe eine wichtige Rolle spielen, um Text und Variablen voneinander zu unterscheiden, und Text in String-Variablen gespeichert wird. GÄNSEFÜSSCHEN Zur Erinnerung: Um mit println einen Text auf den Bildschirm zu schreiben, muss der Text zwischen Gänsefüsschen stehen (vgl. Seite 26). Mit den Gänsefüsschen sagst du Scala, dass die Wörter als»wirkliche Wörter«gemeint sind und nicht als Variablen. scala> var Zahl = 123 Zahl: Int = 123 scala> 123 scala> Zahl println(zahl) println("zahl") Mit Gänsefüsschen unterscheidet Scala zwischen»text«einerseits und Variablen und Rechnungen andererseits. In Gänsefüsschen können auch ganze Rechnungen stehen, die Scala dann einfach buchstabengetreu ausgibt und nicht berechnet. scala> println( ) 62 scala> println(" ") Schau dir diese Beispiele hier genau an. Es ist wichtig, dass du verstehst, wann und warum es die Gänsefüsschen braucht!»string«ist der Datentyp für beliebig langen Text. Auch wenn Scala selber von java.lang.string spricht, genügt String vollkommen. TEXT SPEICHERN Mit Gänsefüsschen gibst du in Scala Text an, der buchstabengetreu genauso ausgegeben wird, wie du ihn eingegeben hast. Du kannst solchen Text aber nicht nur ausgeben, sondern auch in Variablen speichern: scala> var satz = "Scala macht Spass." satz: java.lang.string = Scala macht Spass. scala> println(satz) Scala macht Spass.

46 44 Caesars Verschlüsselung c 2013, Tobias Kohn Beim Speichern in der Variable satz gibt dir Scala den Datentyp als String an (den Vorsatz java.lang kannst du getrost ignorieren). Wörtlich übersetzt heisst»string«zwar»bindfaden«oder»saite«, beim Programmieren ist es aber der Fachbegriff für»text«(der Datentyp»String«wird im Deutschen häufig auch als»zeichenkette«übersetzt). Neben den beiden Datentypen Integer und Double kennst du jetzt also mit String einen dritten Typ. Für Neugierige: Der Vorsatz java.lang kommt daher, weil Scala den Datentyp»String«direkt von Java übernommen hat. Es ist sozusagen ein»quellennachweis«. EINZELNE BUCHSTABEN Für einzelne Buchstaben (oder Satzzeichen) genügen auch Apostrophe anstelle der Gänsefüsschen: scala> x println( x ) Der Datentyp»String«ist für beliebig lange Texte gedacht, während der Datentyp»Char«immer genau ein Buchstabe oder Satzzeichen meint. Es gibt aber einen grossen Unterschied zwischen Gänsefüsschen und Apostoph: Der Text zwischen Gänsefüsschen darf beliebig lang sein. Zwischen die Apostrophe gehört immer genau ein Buchstabe! Andernfalls beschwert sich Scala: scala> println( Ein Wort ) <console>:1: error: unclosed character literal Buchstaben und Satzzeichen werden im Englischen als character bezeichnet. Davon stammt auch die Bezeichnung für den vierten Datentyp: Char ist ein einzelner Buchstabe oder ein Satzzeichen. Mehr dazu im nächsten Abschnitt. PARAMETER Du kennst jetzt den Datentyp für Text. Damit kannst du auch Funktionen schreiben, die z. B. als Parameter einen kurzen Text erwarten. Diese Funktion hier begrüsst jemandem mit dem Namen: scala> def greet(name: String) = { print("hallo "); println(name) greet: (name: String)Unit scala> greet("jack") Hallo Jack Noch einmal: Warum steht das»hallo«in diesem Beispiel in Gänsefüsschen, das»name«aber nicht?

47 c 2013, Tobias Kohn Von Zahlen und Zeichen VON ZAHLEN UND ZEICHEN Worin Buchstaben Zahlen sind und du sogar mit ihnen rechnen kannst. ALLES IST ZAHL Für den Computer sind alle Buchstaben und Satzzeichen zugleich Zahlen. Zum Beispiel ist das grosse»c«eine»67«. Mit Scala lässt sich das sehr einfach bestätigen (Char ist der Datentyp für einzelne Buchstaben und Satzzeichen): Jeder Buchstabe, jedes Satzzeichen und jede Ziffer hat einen eigenen Code. Dabei haben die Gross- und Kleinbuchstaben verschiedene Codes:»A«ist 65,»a«hingegen 97. Für den Computer sind Gross- und Kleinbuchstaben deshalb völlig verschieden und haben grundsätzlich nichts miteinander zu tun. scala> 67 tochar res62: Char = C scala> C toint res63: Int = 67 tochar kannst du hinter jede beliebige (ganze) Zahl stellen, um den zugehörigen Buchstaben daraus zu machen. Weil es aber viel mehr Zahlen als Buchstaben gibt, hat Scala nicht für jede Zahl eine sinnvolle Zuordnung. Für Werte wie 3 oder antwortet Scala nur mit einem Fragezeichen. Die kleinste Zahl mit einem»buchstaben«ist 32: Es ist das Leerzeichen. Genauso wie tochar aus einer Zahl einen Buchstaben macht, macht toint aus einem Buchstaben die zugehörige Zahl. Achte darauf, den Buchstaben (oder das Satzzeichen) in Apostrophe zu setzen. Das ist ähnlich wie bei den Gänsefüsschen für Text: Dank den Apostrophen weiss Scala, dass du den Buchstaben meinst und nicht eine Variable! Die Zahl, die zu einem Buchstaben gehört, heisst ASCII-Code. Der ASCII- Code zu»c«ist also»67«. Auf den ersten Blick mag es ein wenig verwirrend sein, dass auch die einzelnen Ziffern jeweils einen ASCII-Code haben, der nicht mit den Ziffern übereinstimmt: scala> 0 toint res64: Int = 48 scala> 1 toint res65: Int = 49 scala> 2 toint res66: Int = 50 scala> 9 toint res67: Int = 57

48 46 Caesars Verschlüsselung c 2013, Tobias Kohn MIT BUCHSTABEN RECHNEN Dass die Buchstaben eigentlich Zahlen sind, wird noch offensichtlicher, wenn du mit ihnen rechnest. scala> C + 1 res68: Int = 68 scala> S + c + a + l + a res69: Int = 484 scala> Q - 4 res70: Int = 77 scala> 1 * 2 res71: Int = 2450 Aus Scalas Sicht sind die Buchstaben ja alle Zahlen. Daher hat Scala auch kein Problem damit, mit diesen Buchstaben zu rechnen. Weil die Ziffern im letzten Beispiel hier zwischen Apostrophen stehen, rechnet Scala mit den ASCII-Codes 49 und 50 und nicht mit 1 und 2. Für Verschlüsselungen kommt uns das Rechnen mit Buchstaben sehr gelegen. Es ist damit nämlich ein leichtes, Buchstaben zu»verschieben«: Wir addieren einfach z. B. 3 und am Schluss verwandeln wir das Resultat in einen Buchstaben. scala> ( C + 3) tochar res72: Char = F EIN DATENTYP FÜR BUCHSTABEN Einzelne Buchstaben haben den Datentyp Char. Das kommt vom englischen Wort»character«für ein einzelnes (Satz-)Zeichen bzw. einen Buchstaben. Im Gegensatz zum Typ String enthält Char immer genau ein Zeichen. Natürlich kannst du wieder Variablen mit dem Typ Char anlegen. scala> var zeichen = b zeichen: Char = b scala> zeichen toint res73: Int = 98 scala> (zeichen + 3) tochar res74: Char = e

49 c 2013, Tobias Kohn Von Zahlen und Zeichen 47 ASCII UND UNICODE* Der Code, der jedem Zeichen eine Zahl zuordnet, war ursprünglich vor allem als Code für Funkübertragungen gedacht. Aus diesem Grund gibt es auch Zahlen (Codes), die für»beginn der Übertragung«,»Übertragungsende«oder»Klingeln«stehen. Auf dem Computer sind diese Codes inzwischen überflüssig, aber immer noch dabei. Das eigentliche Alphabet mit allen Satzzeichen etc. beginnt deshalb erst bei 32, weil davor all diese speziellen Übertragungscodes stehen. Der ursprüngliche ASCII-Code umfasste 127 Zeichen: Mehr als genug für das englische Alphabet. Später wurde der Code dann auf über Zeichen ergänzt und hiess ab da Unicode. Damit sollen alle Alphabete und Zeichen auf der Welt abgedeckt werden. Scala und Java können davon mit den Codes 0 bis arbeiten, aber nicht alle Zeichen korrekt darstellen (das hängt von den installierten Schriften ab). Die (in Scala) fehlenden Codes ab enthalten vor allem antike Alphabete (z. B. Hieroglyphen). Ein kleines Experiment dazu: Wir speichern den Code in einer Variablen vom Typ Char ab und rechnen dann 100 dazu. Sehen wir uns doch an, welcher Wert dann gespeichert ist... scala> var zeichen = tochar zeichen: Char =? scala> zeichen = (zeichen + 100) tochar res75: Char = c Die Tabelle rechts unten zeigt den wesentlichen Teil der ASCII- Codetabelle.»Internationale Zeichen«wie die deutschen Umlaute Ä, Ö, Ü fehlen hier (sie wurden erst viel später hinzugefügt): Du kannst ihre Codes aber mit Scalas toint leicht bestimmen. scala> zeichen toint res76: Int = 99 Nach beginnt Scala also einfach wieder bei Null P p 33! A 81 Q 97 a 113 q B 82 R 98 b 114 r 35 # C 83 S 99 c 115 s 36 $ D 84 T 100 d 116 t 37 % E 85 U 101 e 117 u 38 & F 86 V 102 f 118 v G 87 W 103 g 119 w 40 ( H 88 X 104 h 120 x 41 ) I 89 Y 105 i 121 y 42 * 58 : 74 J 90 Z 106 j 122 z ; 75 K 91 [ 107 k 123 { 44, 60 < 76 L 92 \ 108 l = 77 M 93 ] 109 m > 78 N 94 ˆ 110 n / 63? 79 O 95 _ 111 o 127

50 48 Caesars Verschlüsselung c 2013, Tobias Kohn AUFGABEN 30. Der kurze Text EHUJ ist entstanden, indem die Buchstaben um 3 Plätze verschoben wurden (A D). Verwende Scala, um das ursprüngliche Wort (den Klartext) wiederherzustellen indem du jeden Buchstaben wieder entschlüsselst. 31. Finde heraus, was die beiden Funktionen toupper bzw. tolower bewirken. Gib dazu z. B. folgendes ein: a toupper oder B toupper 32. Die folgende Funktion wandelt jeden Grossbuchstaben in fortlaufende natürliche Zahlen um, so dass ord( A )=0, ord( B )=1, etc. scala> def ord(zeich: Char) = ((zeich toupper) - A ) ord: (zeich: Char)Int (a) Warum funktioniert ord sowohl mit Gross- als auch mit Kleinbuchstaben? Welche Rolle spielt toupper dabei? (b) Programmiere eine Funktion chr(zahl: Int), die aus einer Zahl wieder den entsprechenden Grossbuchstaben macht. Bsp. chr(2) = C. 33. * Mit welcher Rechnung kannst du einen Kleinbuchstaben in einen Grossbuchstaben verwandeln? Warum funktioniert das nicht für die deutschen Umlaute Ä, Ö, Ü? Hinweis: Sieht dir die Tabelle auf Seite 47 an. 34. * In den Anfangszeiten des Internets war das Verfahren ROT13 populär, um Texte unleserlich zu machen. Dabei handelt es sich um eine Caesar-Verschlüsselung mit dem Schlüssel 13 (also A N A). Verwende die Funktionen chr und ord aus der vorhergehenden Aufgabe und programmiere eine Funktion rot13, die ein Zeichen nach ROT13 ver- bzw. entschlüsselt. Tipp: Auch hier ist das Teilen mit Rest wieder ein nützliches Werkzeug.

51 c 2013, Tobias Kohn Für jeden Buchstaben einmal FÜR JEDEN BUCHSTABEN EINMAL Worin Scala für jeden Buchstaben im Text das gleiche tut. DIE FOR-SCHLEIFE Mit einer Schleife sagst du dem Computer, dass er eine Anweisung oder Berechnung mehrmals wiederholen soll. Wie oft, das hängt von der Schleife ab. Mit der for-schleife, die ich dir hier zeige, wiederholt der Computer deine Anweisung für jeden Buchstaben im Text genau einmal. Und so funktioniert es: scala> SCALA for (b <- "Scala") print(b toupper) Wie beim if sind die Klammern nach for zwingend. Den Pfeil <- kannst du lesen als»in«. Also:»Für jeden Buchstaben b im Text Scala wiederhole das folgende.«die Anweisung, die für jeden Buchstaben ausgeführt wird, ist hier ein einfaches print. Das toupper verwandelt die einzelnen Buchstaben noch in Grossbuchstaben. Mit dem Gegenstück tolower kannst du alle Buchstaben in Kleinbuchstaben umwandeln. Das for braucht immer eine Variable hier das b für die einzelnen Buchstaben. Wie du diese Variable aber nennst, ist dir überlassen. Die Schleife oben kannst du also genauso gut schreiben als: scala> for (buchstabe <- "Scala") print(buchstabe toupper) SCALA Die for-variable ist wie ein Parameter in jedem Schleifendurchgang fest (unveränderlich). Du kannst also die Variable b bzw. buchstabe so oft verwenden, wie du möchtest, aber nicht ändern! BLÖCKE UND FUNKTIONEN Was ist aber, wenn du für die einzelnen Buchstaben mehr als eine Anweisung ausführen möchtest? Dann verwendest du die selbe Technik wie bei Funktionen: Blöcke. Das heisst: Alle Anweisungen, die wiederholt werden sollen, gehören zusammen in geschweifte Klammern. Getrennt werden sie wieder mit einem Semikolon (Strichpunkt). scala> for (b <- "Scala") { print(b toupper); print("*")

52 50 Caesars Verschlüsselung c 2013, Tobias Kohn S*C*A*L*A* Ein Block ist also eine Liste von Anweisungen oder Berechnungen, die mit geschweiften Klammern zusammengefasst und durch Semikola getrennt werden. Während du im interaktiven Modus von Scala arbeitest (in dem du nur einzelne Zeilen eingeben und editieren kannst), ist es sinnvoll, die einzelnen Anweisungen möglichst kurz und getrennt zu halten. Ich würde dir deshalb empfehlen, die Schleife oben nicht mit einem Block, sondern mit einer Funktion zu schreiben. Letzlich geht aber beides! scala> def starprint(zeichen: Char) = { print(zeichen toupper); print("*") starprint: (zeichen: Char)Unit scala> for (b <- "Scala") starprint(b) S*C*A*L*A* Auf der anderen Seite kannst du die for-schleife selbst wiederum in einer Funktion verwenden. Zum Beispiel so: scala> def starprinttext(text: String) = { for (b <- text) starprint(b) starprinttext: (text: String)Unit ZAHLEN DURCHLAUFEN Die for-schleife kann tatsächlich noch viel mehr als nur die Buchstaben in einem String durchgehen. Genauso wichtig ist die Möglichkeit, jede (ganze) Zahl in einem bestimmten Bereich durchzugehen: for-schleifen gehören wie if- Bedingungen zu den häufigsten und wichtigsten Strukturen beim Programmieren. Vor allem die Version mit Zahlen tritt oft auf. scala> for (i <- 40 to 49) print(i) Die Regeln sind genau gleich wie für die Buchstaben in einem String, nur dass i jetzt ein Integer ist und die Zahlen von 40 bis 49 durchläuft. Schauen wir uns zum Abschluss noch eine Anwendung für die for- Schleife mit Zahlen an. Und zwar soll Scala alle Zahlen von 1 bis 100 zusammenzählen. Dazu definieren wir eine Variable resultat für das Ergebnis und zählen nach und nach jede Zahl zu resultat dazu: scala> var resultat = 0 resultat: Int = 0 scala> for (i <- 1 to 100) resultat += i

53 c 2013, Tobias Kohn Für jeden Buchstaben einmal 51 scala> resultat res77: Int = 5050 Das ganze lässt sich auch als eine Funktion definieren, die alle Zahlen von 1 bis n zusammenzählt: scala> def zahlensumme(n: Int) = { var result = 0; for (i <- 1 to n) result += i; result zahlensumme: (n: Int)Int scala> zahlensumme(100) res78: Int = 5050 An dieser Funktion speziell ist die Variable result. Weil die Variable innerhalb der Funktion definiert wird (mit dem var), existiert sie auch nur innerhalb der Funktion! Sobald die Funktion also fertig ist, wird diese Variable wieder gelöscht. Solche Variablen, die nur innerhalb einer Funktion existieren, heissen lokale Variablen. AUFGABEN 35. Lass dir einen Text mithilfe einer for-schleife mit Gross- und Kleinschreibung ausgeben. Der Text»scala«würde dann zu: SsCcAaLlAa. 36. Auf Seite 48 hast du die Funktion ord angegeben, um für einen Buchstaben seine Position im Alphabet auszugeben. Kombiniere das mit einer for-schleife, um für jeden Buchstaben die Position auszugeben.»scala«wird dann zu: Verwende eine for-schleife, um alle Quadratzahlen von 1 2 bis 10 2 zusammenzuzählen. Also: Das Ergebnis sollte 385 sein. 38. Lass Scala das ganze lateinische Alphabet von A bis Z auf den Bildschirm schreiben: ABCDEFGHIJKLMNOPQRSTUVWXYZ Dazu verwendest du eine geschickte for-schleife und gibst das Alphabet nicht selber ein! 39. Schreibe eine Funktion um die Quersumme einer Zahl zu berechnen. Die Zahl gibst du jeweils als String an! scala> quersumme("123") res79: Int = 6

54 52 Caesars Verschlüsselung c 2013, Tobias Kohn Für Profis: Programmiere eine Version, die als Parameter einen Integer erwartet. Tipp: Verwende tostring. 4.5 VERSCHLÜSSELN Worin du einen Text mit Caesars Verfahren ver- und entschlüsselst. Inzwischen hast du alles zusammen, was du brauchst, um die Caesar- Verschlüsselung zu programmieren. In diesem Abschnitt programmieren wir eine Funktion caesar, die einen Text ver- oder entschlüsselt. Dazu teilen wir die Aufgabe in mehrere kleine Portionen auf! In diesem Abschnitt ist key der Schlüssel (also eine Zahl zwischen 1 und 25), der angibt, um wie viele Stellen das Alphabet verschoben wird. BUCHSTABEN ROTIEREN: ERSTE VERSION Das erste Stück für unsere Verschlüsselung ist die Funktion encodecaesar, die einen einzelnen Buchstaben verschlüsselt. Wir schauen uns zwei Möglichkeiten an, wie diese Funktion programmiert werden kann. Die einfachste Version sieht so aus: scala> def encodecaesar(zeichen: Char, key: Int) = (zeichen + key) tochar encodecaesar: (zeichen: Char, key: Int)Char Das Problem an dieser Version: Die Buchstaben am Ende des Alphabets (z. B. Z) fallen aus dem Alphabet heraus. Das sollten wir korrigieren! Nach Z soll wieder A kommen und umgekehrt. scala> def encodecaesar(zeichen: Char, key: Int) = { var result = (zeichen + key); if (result > Z ) result -= 26; if (result < A ) result += 26; result tochar encodecaesar: (zeichen: Char, key: Int)Char Wenn der Buchstabe»grösser«ist als Z, ziehen wir 26 ab und schon ist der Buchstabe wieder im Alphabet drin! Für diese Funktion hier habe ich noch einen»trick«angewandt: Ich habe die Variable result in der Funktion selber definiert. Ganz am Schluss der Funktion steht diese Variable nochmals, damit ihr Wert das

55 c 2013, Tobias Kohn Verschlüsseln 53 Ergebnis der Funktion wird. Weil die Variable innerhalb der Funktion definiert wird, existiert sie auch nur innerhalb der Funktion! In anderen Worten: Sobald die Funktion fertig ist, wird die Variable result wieder gelöscht. Solche Variablen heissen lokale Variablen. BUCHSTABEN ROTIEREN: ZWEITE VERSION Mit den Funktionen ord und chr von Seite 48 und dem Teilen mit Rest lässt sich die Funktion encodecaesar sogar noch etwas eleganzer schreiben. scala> def chr(code: Int) = (code + A ) tochar chr: (code: Int)Char scala> def encodecaesar(zeichen: Char, key: Int) = chr( (ord(zeichen) + key) % 26 ) encodecaesar: (zeichen: Char, key: Int)Char Mit ord(zeichen) wird zuerst die Position des Buchstabens bestimmt. Zu dieser Position wird der Schlüssel key dazugezählt. Für den Schlüssel key=3 ergibt sich also A 3, B 4, Z 28 etc. Der Wert 28 liegt aber jetzt ausserhalb des Alphabets (0 bis 25). Durch das Teilen mit Rest wird 28 wiederum zu 2 und damit zu C. Schliesslich macht chr wieder einen Buchstaben daraus. Diese Version funktioniert allerdings nur für key 0. Falls du einen Schlüssel von 3 verwenden möchtest, dann nimm 23 stattdessen. DEN TEXT VERSCHLÜSSELN Welche Version von encodecaesar du verwendest, spielt hier keine Rolle. Für die Funktion caesar verschlüsseln wir einfach der Reihe nach jeden einzelnen Buchstaben. Damit das sicher funktioniert, werden alle Buchstaben mit toupper in Grossbuchstaben verwandelt. scala> def caesar(text: String, key: Int) = { for (buchstabe <- text) print(encodecaesar(buchstabe toupper, key)); println caesar: (text: String, key: Int)Unit Die einzelnen Teile davon kennst du bereits. Und so verwendest du die Funktion: scala> caesar("caesar", 3) FDHVDU Zum Entschlüsseln kannst du die genau gleiche Funktion verwenden. Du musst nur den Schlüssel richtig wählen...

56 54 Caesars Verschlüsselung c 2013, Tobias Kohn AUFGABEN 40. Entschlüssle den Geheimtext FCPXJGAFCEPYRSJYRGML. Zur Verschlüsselung wurde der Schlüssel 24 verwendet. 41. Der Geheimtext ZKBYKI wurde mit den Caesar-Verfahren verschlüsselt. Leider kennst du den Schlüssel nicht dazu. Programmiere eine for-schleife, die dir alle möglichen Klartexte auf den Bildschirm schreibt (d. h. alle 25 möglichen Schlüssel durchgeht).

57 c 2013, Tobias Kohn Datentypen DATENTYPEN Worin wir einen genaueren Blick auf die Datentypen werfen. DIE VIER UND (K)EIN DATENTYP Scala kennt viele verschiedene Datentypen. Davon brauchst aber nie alle und mit den vier Typen, die du bereits kennst, hast du ein gutes Fundament. Der fünfte Typ hier Unit kommt immer dann vor, wenn etwas keinen Datentyp hat (z. B. Funktionen ohne Resultat). Name Beschreibung Int(eger) Ganze Zahlen bis ca. ± Double Gebrochene Zahlen (Dezimalbrüche) Char Einzelner Buchstabe oder Satzzeichen String Beliebig langer Text: Liste von Chars Unit»Kein Wert sinnvoll oder vorhanden«scala erkennt in den meisten Fällen selber, welchen Typ eine Variable haben muss, um eine Zahl oder einen Buchstaben zu speichern. Mit einem Doppelpunkt kannst du aber auch jederzeit selber angeben, von welchem Typ eine Variable sein soll. scala> var zahla = 123 zahla: Int = 123 scala> var ZahlB: Double = 123 ZahlB: Double = UMWANDLUNGEN Den Datentyp einer Variable kannst du nie ändern! Aber du kannst Werte von einem Typ in einen anderen Typ umwandeln. Du kennst bereits tochar und toint. Dabei funktioniert toint nicht nur für Char, sondern auch für Double und sogar für String, macht aber jeweils etwas anderes: scala> 1 toint res80: Int = 49 scala> "1" toint res81: Int = 1 scala> 3.75 toint res82: Int = 3

58 56 Caesars Verschlüsselung c 2013, Tobias Kohn Zum einen kannst du toint verwenden, um einen Double-Wert abzurunden und in einen Integer-Wert zu verwandeln. In Bezug auf Char und String gibt es aber einen grossen Unterschied: Bei einem Char gibt toint den Buchstaben-Code an. Bei einem String verwandelt toint die Zahl im Text in einen Integer. Falls der String keine Zahl enthält, antwortet Scala mit einer ziemlich langen Fehlermeldung. scala> "456" toint res83: Int = 456 scala> "1a" toint java.lang.numberformatexception: For input string: "1a" Zu jedem der vier Datentypen gibt es entsprechende Umwandlungen: toint, todouble, tochar und tostring. RECHNEN Datentypen sind vor allem wichtig, wenn es ums»rechnen«geht. Das Beispiel hier zeigt dir die Unterschiede, die bei einer einfachen Addition auftreten: scala> res84: Int = 9 scala> res85: Double = 9.0 scala> res86: Int = 105 scala> "3" + "6" res87: java.lang.string = "36" Der Unterschied zwischen Integer und Double fällt hier kaum ins Gewicht. Auf Seite 4 haben wir Integer und Double bereits diskutiert. Zeichen vom Typ Char werden zum Rechnen als Zahlen aufgefasst: Dazu werden die Ziffern zuerst in ihre Codes umgewandelt (hier 51 und 54). Strings werden schliesslich einfach zusammengehängt und nicht wirklich berechnet. FAZIT Je nach verwendeten Datentypen rechnet Scala anders. Du hast jetzt mehrere Anwendungen gesehen, in denen es auch sinnvoll ist, nur mit ganzen Zahlen oder sogar mit den Buchstabencodes zu rechnen. Im Verlaufe des Scripts wirst du noch weitere Datentypen mit eigenen Rechnungsschemata kennenlernen.

59 c 2013, Tobias Kohn Datentypen 57 Integer tochar toint Char todouble toint tostring toint tostring Double tostring todouble String Das Diagramm zeigt die vier wichtigen Datentypen für Zahlen und Text. Die Pfeile geben an, welcher Typ sich in welchen anderen umwandeln lässt. Wichtige Punkte Der Datentyp String (manchmal auch java.lang.string) speichert einen beliebig langen Text. Der Text selber muss immer in Gänsefüsschen eingeschlossen sein. Einzelne Buchstaben oder Satzzeichen speicherst du im Datentyp Char. Ein Char enthält immer genau ein Zeichen. Jedes Zeichen hat einen eindeutigen Code: den ASCII- oder Unicode. Mit toint und tochar kannst du zu einem Zeichen den Code bestimmen oder aus einem Code das zugehörige Zeichen erstellen. Mit toupper und tolower kannst du lateinische Buchstaben in Gross- bzw. Kleinbuchstaben umwandeln. Allerdings funktioniert das nicht für deutsche Umlaute. Eine for-schleife wiederholt eine Anweisung für jeden Buchstaben in einem String oder jede (ganze) Zahl in einem bestimmten Bereich. Wenn eine Schleife mehrere Anweisungen ausführen soll, dann kannst du die Anweisungen in einem Block zusammenfassen. Ein Block ist eine Liste von Anweisungen und in geschweifte Klammern eingeschlossen. Die einzelnen Anweisungen werden mit Semikola getrennt. Für Zahlen und Text gibt es vier wichtige Datentypen: Int, Double, Char und String. Der Datentyp legt fest, wie Scala mit den Werten rechnet. Zudem gibt der Datentyp auch immer die»form«einer Variablen an (und bestimmt damit, was in einer Variablen gespeichert werden kann). Mit Befehlen wie toint oder tostring lassen sich die Werte von einem Datentyp in einen anderen umwandeln.

60 58 Caesars Verschlüsselung c 2013, Tobias Kohn 11. Die Variable zeichen ist vom Typ Char und enthält einen lateinischen Buchstaben. Was überprüft dann die folgende if- Bedingung? scala> if (zeichen >= a ) print(zeichen toupper) a. Ob die Variable zeichen ein kleines a enthält. b. c. Ob die Variable zeichen einen Grossbuchstaben enthält. Ob die Variable zeichen einen Kleinbuchstaben enthält. d. Ob die Variable zeichen einen Buchstaben enthält. 12. Die beiden Funktionen tolower und toupper lassen sich auch kombinieren: scala> a ( a toupper) tolower Heben sich toupper und tolower in einer solche Kombination immer gegenseitig auf? a. Ja, tolower verwandelt alle Grossbuchstaben wieder zurück in Kleinbuchstaben. b. c. Nein, es funktioniert nur für Kleinbuchstaben. Nein, es funktioniert nur für Grossbuchstaben. d. Nein, es funktioniert nicht für Umlaute (ÄÖÜ).

61 k a p i t e l f ü n f ECLIPSE Lernziele Wie erstellst du in Eclipse ein neues Scala-Projekt? Wie führst du deinen Scala-Code aus? Was ändert sich, wenn du deinen Code über Eclipse ausführst? Wie gibst du einfache Meldungen auf den Bildschirm aus? Wo schreibst du deinen Programmcode hin? 5.1 PROJEKTE ERSTELLEN Worin du in Eclipse ein neues Projekt erstellst und dein erstes Programm ausführst. Für einzelne Anweisungen ist die interaktive Umgebung von Scala sehr praktisch. Sobald du aber grössere Programme schreibst, brauchst du eine bessere Umgebung dafür. In diesem Kapitel beginnst du, mit der Entwicklungsumgebung»Eclipse«zu arbeiten. In Eclipse lässt sich rechts oben die»scala Perspective«einstellen. Stell sicher, dass in Eclipse rechts oben die»scala perspective«eingestellt ist. Ganz links oben findest du dann ein Symbol, über das du neue Elemente hinzufügen kannst: Wähle daraus das»scala project«. Im Dialogfeld gibst du anschliessend einen Namen für dein Projekt ein. Hier empfiehlt sich z. B.»MeinErstesProjekt«. Das Projekt alleine hat lediglich ein Verzeichnis angelegt. Für das eigentliche Programm brauchst du natürlich eine Datei, um den Quelltext einzugeben. Füge also wiederum über die Schaltfläche links oben ein»scala Object«hinzu. Auch dafür musst du wiederum einen Namen angeben, etwa»meinerstesprogramm«. Wähle zudem das Kästchen»public static void main(string args[])«aus.

62 60 Eclipse c 2013, Tobias Kohn Nachdem Eclipse eingerichtet ist und du ein Projekt mit einem Objekt darin erstellt hast, sieht das Fenster etwa so aus. Beachte ganz oben links die Schaltfläche, um neue Projekte und Objekte hinzuzufügen. Oben rechts schaltest du bei Bedarf auf die»scala Perspektive«um. Der»Project Explorer«links zeigt dir alle Projekte an, die du anlegst. Da du mit der Zeit eine ganze Reihe von Projekten hast, ist es sinnvoll, den Projekten gute Namen zu geben. In der Mitte gibst du den Quellcode für das Programm ein und ganz unten erscheinen Fehler im Abschnitt»Problems«und die Ausgabe deines Programms im Abschnitt»Console«. EIN PROGRAMM SCHREIBEN Schliesslich kannst du mit dem Programmieren beginnen. Scala hat bereits etwas Programmtext hingeschrieben: object MeinErstesProgramm { def main(args: Array[String]): Unit = { Die einen Elemente davon kennst du bereits, andere sind noch neu. In der ersten Zeile findest du den Namen wieder, den du zuvor bei»neues Object«angegeben hast. Darunter findest du im Wesentlichen eine Funktion main, allerdings ist diese Funktion im Moment noch leer. Der Parameter dieser Funktion ist args: Array[String]. Das ist ein Überbleibsel von früher, das wir nicht brauchen aber leider trotzdem hinschreiben müssen. Das Unit könnten wir auch weglassen: Es sagt nur aus, dass diese Funktion kein Ergebnis hat. Es ist Tradition, mit dem ersten Programm in einer neuen Umgebung oder Sprache zuerst einmal»hallo Welt«auf den Bildschirm zu schreiben. Die Anweisung dazu kennst du bereits: println.

63 c 2013, Tobias Kohn Projekte erstellen 61 object MeinErstesProgramm { def main(args: Array[String]) { println("hallo Welt!") Nachdem du auf»run as... «(das grüne»play«-symbol) geklickt hast, musst du leider jedes Mal noch angeben, dass dein Programm tatsächlich ein Scala-Programm ist. Klicke anschliessend auf das»play«-symbol oben (wenn du mit der Maus darüberfährst, erscheint der Hilfstext»Run as...«). Eclipse will dann von dir wissen, ob das ein Java oder Scala Programm ist. Doppelklicke auf»scala Application«. Ganz unten im Bildschirm sollte im Reiter»Console«jetzt der Text»Hallo Welt!«erscheinen. Ändere dein erstes Eclipse-Scala-Programm ein wenig ab und mach dich so vertraut mit Eclipse und wie du Programme schreiben und ausführen kannst. Achte darauf, alle Anweisungen in die Funktion main hineinzuschreiben! Der nächste Abschnitt gibt ein weiteres Beispiel. BEGRÜSSEN* Dass Scala die Welt begrüsst ist zwar hübsch, aber letzlich möchte ich das ein wenig persönlicher: Scala soll schliesslich uns Untertan sein. Dazu schlage ich ein Programm vor, das deinen Namen erfragt und dich dann mit Namen begrüsst. Und so sieht der Code dazu aus: object MeinErstesProgramm { def main(args: Array[String]) { print("gib deinen Namen ein: "); var name = readline; print("hallo "); println(name) Wiederum dürfte dir davon alles vertraut sein ausser der Anweisung readline. Damit soll Scala beim Ausführen darauf warten, dass du etwas eingibst. Durch die Verbindung Mit readline sagst du Scala, dass du diesen Wert erst eingeben möchtest, wenn das Programm bereits läuft. var name = readline; wird das, was du eingibst in der Variable name gespeichert. Führe das Programm wiederum über das Play-Symbol aus. Scala fordert dich im»console«-bereich unten auf, deinen Namen einzugeben. Damit du auch effektiv deinen Namen eingeben kannst, musst du zuerst mit der Maus in den»console«-bereich klicken.

64 62 Eclipse c 2013, Tobias Kohn 5.2 OBJEKTE UND FUNKTIONEN Worin neben main noch andere Funktionen zum Objekt gehören. OBJECT MEINPROGRAMM Was hat es eigentlich mit diesem object in der ersten Zeile auf sich? Dahinter steckt eine Idee aus der sogenannten»objektorientierten Programmierung«(kurz»OOP«). Weil grosse Programme typischerweise hunderte von Funktionen und Variablen umfassen, werden diese Funktionen zu Objekten zusammengefasst. Das Objekt»MeinErstesProgramm«hier ist also eine Sammlung von allen Funktionen und Variablen, die zusammen dein Programm ausmachen. HIER GEHT S LOS: MAIN Dein Programm darf neben main noch viele andere Funktionen enthalten. Die Reihenfolge, in der du die Funktionen programmierst, spielt keine Rolle. Scala sucht sich einfach immer die Funktion main heraus und führt sie aus. Der Name»main«kommt aus dem Englischen und lässt sich etwa mit»hauptteil«oder»hauptsache«übersetzen. So könnte zum Beispiel ein Programm aussehen, das neben main noch andere Funktionen enthält: object MeinErstesProgramm { def quadrat(x: Double) = x * x def doppel(x: Int) = 2 * x Scala führt immer die Funktion»main«aus. Allerdings nur, wenn auch der Parameter args richtig angegeben ist. Zudem darf jedes Projekt nur genau eine»main«- Funktion enthalten. def main(args: Array[String]) { print("das Quadrat von 15 ist: "); println( quadrat(15) ) Was du dir merken solltest: Das Programm-Objekt ist eine Sammlung von allen Funktionen und Variablen, die zu deinem Programm gehören. Von den Funktionen sucht sich Scala immer die Funktion main heraus und führt sie aus. Andere Funktionen führt Scala nur aus, wenn du das innerhalb von main angibst. Die Funktion doppel im Quelltext oben wird zum Beispiel nie ausgeführt bzw. berechnet!

65 c 2013, Tobias Kohn Nachrichten ausgeben NACHRICHTEN AUSGEBEN Worin Scala nur noch schreibst, was du explizit angibst. SCALA SCHREIBT NUR NOCH MIT PRINTLN Am Anfang des Script hast du in Scala folgende Berechnung ausgeführt: scala> 5+12*31 res88: Int = 377 Wenn du in Eclipse programmierst, schreibt Scala grundsätzlich nichts mehr auf den Bildschirm. Wenn du trotzdem möchtest, dass etwas geschrieben wird, dann musst du das explizit angeben. Dieselbe Rechnung kannst du auch jetzt noch angeben, allerdings passiert damit offenbar nichts. Es gibt einen wesentlichen Unterschied zwischen dem interaktiven Modus der ersten Kapitel und Programmen, die du in Eclipse schreibst: Im interaktiven Modus schreibt Scala ALLES auf den Bildschirm. Aus Eclipse heraus schreibt Scala grundsätzlich NICHTS auf den Bildschirm! Falls du also möchtest, dass Scala dir das Ergebnis einer Berechnung ausgibt, dann musst du das mit println explizit angeben! object MeinErstesProgramm { def main(args: Array[String]) { println(5+12*31) DIE NACHRICHT IM FENSTER Die Ausgaben im»console«-bereich von Eclipse sind zwar praktisch, aber ich zeige dir gleich von Anfang an, wie du deine Nachrichten moderner ausgeben kannst: In einem»dialog«(»dialoge«sind kleine Fenster, die meistens nur kurz erscheinen). Und so funktioniert s: import swing.dialog.showmessage object MeinErstesProgramm { def main(args: Array[String]) { showmessage(message = "Hallo Welt!") Magst du dich an import (s. S. 8) erinnern? Damit laden wir hier aus dem Paket swing.dialog die Funktion showmessage. In der main-funktion brauchen wir dann showmessage, um unsere Nachricht mit einem Dialogfenster auszugeben. Mehr dazu im nächsten Kapitel!

66 64 Eclipse c 2013, Tobias Kohn Wichtige Punkte Für jedes neue Programm erstellst du in Eclipse zuerst ein neues Projekt und dann im Projekt ein neues»scala Object«. Wenn die Programme grösser und komplizierter werden, enthält ein Projekt dann meistens mehrere Dateien. Zum Ausführen (engl.»run«) deines Codes klickst du auf das grüne»play«-symbol. Anschliessend gibst du an, dass es sich um eine»scala Application«handelt. Jedes Scala-Programm besteht aus einem Programm-Objekt, das alle Funktionen und Variablen enthält. Innerhalb des Programm- Objekts wird dann die Funktion main ausgeführt. Dazu braucht main den richtigen Parameter: def main(args: Array[String]) = {... In Eclipse schreibt Scala grundsätzlich nur noch das auf den Bildschirm, was du mit println angibst. Die Ausgaben erscheinen im Eclipse-Fenster ganz unten im»console«-bereich. Mit readline gibst du Scala an, dass der entsprechende Wert erst eingegeben wird, wenn das Programm läuft. readline erkennt aber keine Zahlen: Alle Eingaben sind hier immer vom Datentyp»String«! Das Paket swing.dialog enthält die Funktion showmessage, mit der du ein kleines Fenster für die Ausgaben erzeugst. AUFGABEN 42. Im letzten Kapitel hast du die Caesar-Verschlüsselung programmiert. Übertrage die nötigen Funktionen in ein Eclipse-Projekt und schreibe ein Programm, das dich über readline auffordert, einen Text einzugeben, der dann verschlüsselt und wieder ausgegeben wird. Tipp: Wenn du für die Verschlüsselung den Schlüssel 13 wählst, dann kannst du mit dem gleichen Programm die Texte wieder entschlüsseln (ROT13-Verfahren).

67 k a p i t e l s e c h s DAS KLEINE EIN-MAL-EINS Lernziele Wie wählt Scala zwischen zwei Alternativen aus? Wie verbindest du mehrere Bedingungen zu einer einzigen? Wie kann dein Programm Eingaben entgegennehmen? Warum verpacken einige Funktionen ihr Resultat in ein Some? Wie kannst du eine Funktion mehrfach wiederholen? In diesem Kapitel programmieren wir zusammen ein Quiz zum Üben des kleinen Ein-Mal-Eins. Der Computer stellt eine Rechenaufgabe, z. B.»3 5«und du musst dann das richtige Ergebnis eingeben. Für diese Aufgabe brauchst du zwei wesentliche Techniken: Zum einen musst du Ein- und Ausgaben programmieren können (der Computer soll die Frage stellen und die Antwort entgegennehmen). Zum anderen soll das Quiz beliebig oft wiederholt werden, ohne dass du jedes Mal das Programm neu starten musst. Es geht also auch um eine Technik zum Wiederholen. 6.1 MEHR BEDINGUNGEN Worin Scala eine von zwei Alternativen auswählt und Bereiche prüft. IF-BEDINGUNG Du möchtest, dass ein Programmcode nur unter bestimmten Bedingungen ausgeführt wird? Dann verwendest du dazu eine if-bedingung. Das funktioniert sowohl für einzelne Anweisungen als auch für Blöcke von mehrere Anweisungen (ein»block«ist eine Liste von Anweisungen und ist immer in geschweifte Klammern eingeschlossen).

68 66 Das kleine Ein-Mal-Eins c 2013, Tobias Kohn if (x > 10) { println("x ist zu gross und wird auf 10 gesetzt"); x = 10 IF UND ELSE Im Unterschied zu einer reinen if-bedingung wählt Scala bei if else immer eine von zwei Alternativen aus (engl.»else«heisst übersetzt»andernfalls«). Das Muster sieht so aus: if (x == 3) println("x ist drei") else println("x ist nicht drei"); Theoretisch könntest du alle else-bedingung auch ausformulieren: if (x == 3) println("x ist drei") if (x!= 3) println("x ist nicht drei"); Mit else wird es aber etwas übersichtlicher, klarer und vor allem ersparst du dir ein wenig Arbeit. MEHRERE BEDINGUNGEN ZUSAMMENFASSEN Stell dir vor, du müsstest prüfen, ob der Wert der Variablen x in einem bestimmten Bereich liegt, sagen wir zwischen 10 und 20. Wie prüfst du das? Im Moment ginge das nur mit einer unübersichtlichen Verschachtelung: if (x >= 10) { if (x <= 20) println("x liegt im Bereich") Zum Glück lässt sich das viel kürzer schreiben und zwar mit dem»und«- Operator &&: if (x >= 10 && x <= 20) println("x liegt im Bereich") Mit dem und-operator kannst du beliebige Bedingungen und Tests miteinander verknüpfen: if (x == 123 && y < 456 && eingabe > 0)...

69 c 2013, Tobias Kohn Mehr Bedingungen 67 IF-ELSE FÜR PROFIS* Traditionell werden if else-konstrukte verwendet, um die richtige Anweisung auszuwählen. Dabei kommt öfters das folgende Muster vor: if (eingabe >= 50) zahl = 100 else zahl = 1 In Scala lässt sich das zu einer einzigen Anweisung abkürzen: zahl = if (eingabe >= 50) 100 else 1 Falls du bereits in»c«programmiert hast, kennst du vielleicht das Fragezeichen-Konstrukt, das ähnlich funktioniert. AUFGABEN 43. Schreibe eine Funktion max(a, b), die die grössere der beiden Zahlen a und b zurückgibt. Im interaktiven Modus wäre dann z. B.: scala> max(14, 3) res89: Int = Der Betrag x einer Zahl ist in der Mathematik folgendermassen definiert: { x für x 0, x = x sonst. Übersetze das in eine Scala-Funktion betrag(x: Double). 45. Schreibe ein Programm, das für eine Zahl x überprüft, ob sie dreistellig und durch 7 teilbar ist und das Ergebnis der Überprüfung auf den Bildschirm schreibt.

70 68 Das kleine Ein-Mal-Eins c 2013, Tobias Kohn 6.2 ÜBER DIALOGE KOMMUNIZIEREN Worin Scala kleine Fensterchen erzeugt, um dir etwas anzuzeigen oder dich um eine Eingabe zu bitten. AUSGABEN MIT DIALOGEN Dialoge sind kleine Fensterchen, mit denen du kurze Informationen ausgeben oder Eingaben entgegennehmen kannst. Das Paket swing.dialog enthält solche Dialoge. Du hast damit im letzten Kapitel auch bereits eine kurze Nachricht (engl. message) ausgegeben. import swing.dialog._ object HelloWorldApp { def main(args: Array[String]) { showmessage(message = "Bonjour!") Du kannst neben der eigentlichen Nachricht auch den Titel des Dialog- Fensterchens mitangeben: showmessage(message = "Bonjour!", title = "Morgen") Die Nachricht darf sogar eine Zahl sein. Scala wandelt sie dann selber automatisch in einen String um. showmessage(message = 123) Bei einem showmessage hält Scala das Programm so lange an, bis der Anwender im Ausgabefensterchen auf»ok«geklickt hat. Erst dann geht das Programm weiter. ZU EINER EINGABE AUFFORDERN Wenn der Anwender des Programms etwas eingeben soll, dann kannst du dafür auch einen Dialog verwenden. Der Dialog für Eingaben (engl. input) heisst showinput und braucht noch zusätzliche Angaben. Und so sieht das im Programm aus: import swing.dialog._ object HelloWorldApp {

71 c 2013, Tobias Kohn Über Dialoge kommunizieren 69 def main(args: Array[String]) { showinput(message="wie heisst du?", initial="") Mit message gibst du wie zuvor eine Nachricht an, die im Dialogfenster angezeigt wird. Für das Eingabefeld brauchst du einen Anfangswert initial, der in diesem Beispiel leer (»nichts«) ist. Probiere das Programm aus und ändere die Werte für message und initial ab, um ein Gefühl dafür zu bekommen, was passiert. Du kannst wie bei showmessage auch den Fenstertitel verändern. DIE EINGABE ENTGEGENNEHMEN: SOME UND NONE Eines vorweg: Alle Eingaben sind zunächst einmal vom Datentyp String. Wenn du eine Zahl brauchst, dann musst du die Eingabe selber umwandeln! Weil du die Eingabe ja beim Programmieren noch nicht kennst, bleibt dir nicht viel anderes übrig, als sie in einer Variablen zu speichern. Das nächste Programm tut nichts anderes, als die Eingabe einfach wieder auf die Console zu schreiben (was zugegeben nicht sehr fantasievoll ist). import swing.dialog._ object HelloWorldApp { def main(args: Array[String]) { var eingabe = showinput(message = "Schreib etwas:", initial = ""); println(eingabe) Wenn sich eine Funktion in Scala nicht sicher ist, ob sie ein sinnvolles Resultat liefern kann, dann packt sie das Resultat in ein Some oder gibt ein None zurück. Aus einer Some-Variable kannst du mit get den eigentlichen Wert extrahieren. Schau dir einmal genau an, was Scala da in den Console ausgibt. Egal, was du ins Fenster schreibst, Scala packt ein Some dazu. Zum Beispiel: Some(Scala macht Spass!) Es gibt nur einen Fall, bei dem das Some nicht erscheint. Führe das Programm noch einmal aus, aber klicke im Eingabefensterchen auf»abbrechen«bzw.»cancel«anstatt auf»ok«. Die Antwort in der Eingabevariable ist dann None. Some (engl. etwas, einige) ist Scalas Art, dir zu sagen, dass etwas eingegeben wurde. None (engl. kein, nichts) hingegen bedeutet, dass nichts eingegeben wurde: Der Anwender hat auf»abbrechen«geklickt. Bleibt nur die Frage, wie du das Some wegkriegst. Indem du.get an die Variable anhängst wie im nächsten Programm unten.

72 70 Das kleine Ein-Mal-Eins c 2013, Tobias Kohn Dieses Programmfragment hier nimmt eine Eingabe entgegen, prüft mit if, ob überhaupt etwas eingegeben wurde und gibt das Ergebnis dann wieder in der Console aus. var eingabe = showinput(message = "Schreib etwas:", initial = ""); if (eingabe == None) println("du hast nichts eingegeben!") else println(eingabe.get) Die echte Eingabe ist also in eingabe.get versteckt. Und wenn du eine Zahl brauchst? Dann hängst du an das get noch ein toint an: eingabe.get.toint. JA ODER NEIN? Schliesslich gibt es noch einen dritten Dialog, mit dem Scala den Anwender nach einem»ja«oder»nein«fragt. Der dritte Dialog heisst showconfirmation nach dem englischen Wort confirmation für»bestätigung«. var antwort = showconfirmation(message = "Fliegen Fliegen?"); if (antwort == Result.Yes) println("gut geraten!") if (antwort == Result.No) println("pech gehabt!") AUFGABEN 46. Schreibe ein Begrüssungsprogramm mit Dialogen: Ein erster Dialog fordert den Anwender auf, seinen Namen einzugeben. Danach begrüsst der Computer den Anwender mit Namen, z. B.»Hallo Yoda!«

73 c 2013, Tobias Kohn Mit Rekursion zurück zum Anfang MIT REKURSION ZURÜCK ZUM ANFANG Worin du mit Rekursion eine Funktion immer und immer wieder ausführen kannst. Rekursion ist eine sehr mächtige Programmiertechnik, mit der du z. B. wieder an den Anfang einer Funktion zurückspringen kannst. Du hast damit im Endeffekt also eine Art von»schleife.«verwende die Rekursion aber nur mit einer if-bedingung ganz am Ende der Funktion! DAS GRUNDPROGRAMM Das folgende Programm fordert dich auf, eine Zahl einzugeben und quadriert dann diese Zahl. Wenn du beim Eingeben der Zahl auf»abbrechen«klickst, passiert allerdings nichts. import swing.dialog._ object QuadrateApp { Wenn du das toint (oder tostring) mit einem Punkt an eine Variable»klebst«, dann wird wirklich nur gerade der Inhalt dieser Variable umgewandelt und nicht die ganze Rechnung. def quadriere = { var eingabe = showinput(message = "Gib eine Zahl ein:", initial = ""); if (eingabe!= None) { var zahl = eingabe.get.toint; showmessage(message = zahl * zahl) def main(args: Array[String]) { quadriere DARF ES EINE RUNDE MEHR SEIN? Jetzt verändern wir die main-funktion im Grundprogramm. Wir fragen den Anwender, ob er nochmals eine Zahl quadrieren möchte. Wenn ja, dann soll Scala wieder zum Anfang zurückspringen. def main(args: Array[String]) { quadriere; var nochmals = showconfirmation(message="noch eine Runde?"); if (nochmals == Result.Yes) main(args)

74 72 Das kleine Ein-Mal-Eins c 2013, Tobias Kohn Was passiert hier? Zuerst wird immer noch die Funktion zum Quadrieren aufgerufen. Danach erzeugt Scala ein Fenster und fragt nach, ob der Anwender noch eine Runde möchte. Falls er auf»ja«bzw.»yes«klickt, dann springt Scala zurück an den Anfang der main-funktion! Dazu gibst du einfach den Funktionsnamen main zusammen mit dem Parameter args an. OHNE FRAGE WIEDERHOLEN Das Grundprogramm können wir aber auch anders verändern. In dieser Version hier wiederholt sich die Funktion quadriere selber immer wieder. Aber nur so lange wie der Anwender jeweils auf»ok«klickt. Klickt er hingegeben auf»abbrechen«, dann ist die Eingabe ja None und das Programm beendet sich ganz gewöhnlich. import swing.dialog._ object QuadrateApp { def quadriere = { var eingabe = showinput(message = "Gib eine Zahl ein:", initial = ""); if (eingabe!= None) { var zahl = eingabe.get.toint; showmessage(message = zahl * zahl); quadriere def main(args: Array[String]) { quadriere Weil die Funktion quadriere keine Parameter hat, genügt es auch, zur Rekursion den Namen alleine anzugeben. ABZÄHLEN Wie viele Quadratzahlen hat das Programm am Schluss berechnet? Solche Statistiken sind immer eine tolle Sache und so wollen wir das hier mitaufnehmen. Kanst du dir vorstellen, wie du das Programm ändern musst, damit es die Anzahl der berechneten Quadratzahlen mitzählt? Für das Zählen fügen wir eine Zählvariable ein und erhöhen ihren Wert jedes Mal, wenn quadriere aufgerufen wird. Das Programm sieht dann so aus: import swing.dialog._ object QuadrateApp {

75 c 2013, Tobias Kohn Mit Rekursion zurück zum Anfang 73 var anzahlquadrate = 0 def quadriere = { var eingabe = showinput(message = "Gib eine Zahl ein:", initial = ""); if (eingabe!= None) { anzahlquadrate += 1; var zahl = eingabe.get.toint; showmessage(message = zahl * zahl); quadriere def main(args: Array[String]) { quadriere; showmessage(message = "Du hast insgesamt " + anzahlquadrate.tostring + " Quadrate berechnet!") Warum kannst du die Variable anzahlquadrate nicht direkt in der Funktion quadriere definieren? Weil alle Variablen, die innerhalb der Funktion definiert werden, bei jedem Funktionsstart wieder gelöscht und neu erzeugt werden. Eine Variable, die ausserhalb der Funktionen definiert ist (wie hier die Zählvariable) heisst auch globale Variable. Mit Hilfe der Zählvariable kannst du auch die Anzahl der Quadrate beschränken. Füge dazu nochmals eine entsprechende if-bedingung ein: def quadriere = { var eingabe = showinput(message = "Gib eine Zahl ein:", initial = ""); if (eingabe!= None) { anzahlquadrate += 1; var zahl = eingabe.get.toint; showmessage(message = zahl * zahl); if (anzahlquadrate < 3) quadriere FAZIT Die Rekursion ist eine Technik, bei der du innerhalb einer Funktion wieder an den Anfang der Funktion zurückspringst. Damit kannst du»schleifen«erzeugen: Ein Programmteil, der sich selber wiederholt. Damit aber keine Endlosschleifen entstehen, gehört der Rekursionsaufruf

76 74 Das kleine Ein-Mal-Eins c 2013, Tobias Kohn immer in eine if-bedingung und jeweils ganz an den Schluss einer Funktion! AUFGABEN 47. Verändere die zweite Version (ohne Frage wiederholen) des Quadriere-Programms so, dass es auch dann aufhört, wenn du eine negative Zahl eingibst. 48. Schreibe ein Programm, das anstelle der Quadrate die Wurzeln der eingegebenen Zahlen berechnet und ausgibt. Dazu sollen die Zahlen natürlich vom Typ Double sein (auch die Eingaben). 49. Der Computer kann keine Wurzeln von negativen Zahlen ziehen. Wenn du beim Wurzelprogramm aus der letzten Aufgabe z. B. 1 eingibst, dann antwortet der Computer mit NaN (engl.»not a number«). Erweitere dein Programm so, dass es sich bei negativen Zahlen beschwert und anstatt NaN etwas ausgibt wie»negative Zahlen haben keine Wurzeln.«50. Warum ist es eine schlechte Idee, die quadriere-funktion so wie hier zu wiederholen? def quadriere = { var eingabe = showinput(message = "Zahl:", initial = ""); if (eingabe!= None) { var zahl = eingabe.get.toint; showmessage(message = zahl * zahl); quadriere 51. Schreibe mit der Rekursion ein Programm, das alle Quadratzahlen von 1 bis 10 auf den Bildschirm (Console) schreibt. Verwende dazu eine geeignete Zählvariable. 52. Schreibe ein Programm zum Summieren. Du kannst also wie beim»quadrate«-programm oben der Reihe nach Zahlen eingeben. Wenn du auf»abbrechen«klickst, dann gibt dir das Programm am Schluss die Summe aller eingegebenen Zahlen aus. import swing.dialog._ object SummenApp { var summe = 0 def summiere = {... def main(args: Array[String]) {

77 c 2013, Tobias Kohn Mit Rekursion zurück zum Anfang 75 summiere; showmessage(... )

78 76 Das kleine Ein-Mal-Eins c 2013, Tobias Kohn 6.4 DAS EIN-MAL-EINS ABFRAGEN Worin du das Programm schreibst, um das Ein-Mal-Eins abzufragen. Das Programm stellt eine Multiplikationsaufgabe wie»3 7«und fordert dich auf, das Ergebnis anzugeben. Die zwei Zahlen (hier 3 und 7) erzeugen wir mit dem Zufallsgenerator, den du bereits kennst. Danach prüfen wir, ob der Anwender»OK«geklickt hat. Zur Erinnerung: Das Ergebnis von showinput ist ein String, der in ein Some eingepackt ist. Wir brauchen daher ein get und ein toint, um das Ergebnis in einen Integer umzuwandeln. import swing.dialog._ object EinMalEinsApp { var zufall = util.random; var richtige = 0; def abfrage { var zahl1 = zufall.nextint(10); var zahl2 = zufall.nextint(10); var eingabe = showinput(message = zahl1.tostring + " * " + zahl2.tostring, initial = ""); if (eingabe!= None) { var resultat = eingabe.get.toint; if (result == zahl1 * zahl2) richtige += 1; abfrage def main(args: Array[String]) { abfrage Das Programm ist so aber noch nicht fertig: Zwar werden die richtigen Antworten gezählt, aber der Anwender erfährt nie, ob eine Aufgabe richtig war oder wie viele richtige Antworten er gegeben hat.

79 c 2013, Tobias Kohn Das Ein-Mal-Eins abfragen 77 AUFGABEN 53. Vervollständige das Programm oben, so dass es folgende Punkte erfüllt: Die Zufallszahlen sollen im Bereich 1 bis 10 liegen. Nach jeder Rechnung erhält der Anwender eine Rückmeldung, ob die Antwort richtig war. Je nach Geschmack kannst du das mit einem Dialog machen oder einfach auf der Console eine entsprechende Rückmeldung ausgeben. Am Schluss gibst du dem Anwender an, wie viele richtige und falsche Antworten er gegeben hat. Wenn du magst, kannst du auch eine Note setzen. Wichtige Punkte Mit if und else wählt Scala zwischen zwei möglichen Alternativen aus. Das if enthält jeweils die Bedingung, die entscheidet, welche Alternative ausgewählt wird. Das else enthält nie eine Bedingung. Mehrere Bedingungen kannst du mit dem und-operator && so zusammenfassen, dass alle Teilbedingungen gleichzeitig erfüllt sein müssen. Das ist besonders praktisch für die Überprüfung von Bereichen (z. B. x zwischen 1 und 4). Scala kennt drei Standard-Dialoge, um Nachrichten anzuzeigen, Eingaben entgegenzunehmen oder eine Ja-Nein-Frage zu stellen: showmessage, showinput und showconfirmation. Das Ergebnis von showinput ist entweder None (nichts) oder ein String, der in ein Some verpackt ist. Mit get kannst du den String aus dem Some herausnehmen. Mit der Rekursion kannst du eine Funktion mehrfach wiederholen. Dabei springst du am Ende der Funktion wieder an den Anfang zurück. Damit keine Endlosschleife entsteht, sollte der Sprung zum Anfang immer in einer if-bedingung stehen.

80 78 Das kleine Ein-Mal-Eins c 2013, Tobias Kohn

81 k a p i t e l s i e b e n SWING Lernziele Wie erzeugst du ein Hauptfenster? Welche GUI-Elemente gibt es? Wie setzst du GUI-Elemente in dein Fenster hinein? Wie können deine Schaltflächen auf Mausklicks reagieren?»swing«ist die grafische Benutzeroberfläche von Java. Du kannst damit eigene Fenster mit Textfeldern, Schaltflächen und anderen Elementen zusammenstellen. Die ganze Swing-Bibliothek umfasst dutzende solcher Elemente, die wir hier nicht alle aufführen können. Dieses Kapitel ist vielmehr ein erster Einstieg. Neben»Swing«triffst du auch auf die beiden Begriffe»GUI«und»AWT«.»GUI«steht dabei für»graphical User Interface«und meint»grafische Benutzeroberfläche«. Für die GUI-Programmierung wurde in Java ursprünglich die AWT-Bibliothek zusammengestellt (AWT steht für Abstract Window Toolkit). Diese wurde aber relativ bald durch die neuere Swing-Bibliothek ergänzt bzw. teilweise ersetzt. Wir programmieren hier hauptsächlich mit der Swing-Bibliothek. Ab und an brauchen wir aber auch ein Element aus der älteren AWT-Bibliothek. In diesem Kapitel zeige ich dir verschiedene Techniken und Möglichkeiten zur GUI-Programmierung. Das Thema ist viel zu umfangreich und zu komplex, um alles zu besprechen und zu erklären. Ich kann leider auch nicht immer auf alle Details eingehen. Spiele am besten mit den gezeigten Elementen, bis du ein gutes Gefühl dafür hast. Am Ende des Kapitels programmieren wir einen kleinen Taschenrechner, der die wesentlichen Punkte zusammenfasst.

82 80 Swing c 2013, Tobias Kohn 7.1 DAS HAUPTFENSTER Worin du dein erstes GUI-Fenster erzeugst. EIN LEERES FENSTER Ein neues leeres Fenster erzeugst du über die Anweisung new MainFrame. Dabei ist MainFrame Scalas Name für Haupt-Fenster und new bedeutet, dass du ein neues solches Fenster anlegen möchtest. Das Fenster speichern wir in der Variablen window. Sobald das Fenster erzeugt ist, veränderst du seine Eigenschaften je nach Bedarf. In unserem Fall geben wir dem Fenster einen Titel (title), einen Platz auf dem Bildschirm (location) und eine Grösse (size). Vergiss das new vor dem Point und Dimension nicht. Wenn alle Eigenschaften gesetzt sind, ganz am Schluss, machst du das Fenster sichtbar, indem du visible (sichtbar) auf den Wert true (wahr) setzst. import swing._ import java.awt.dimension object MyFirstSwingApp { def main(args: Array[String]) { var window = new MainFrame window.title = "Meine erste Swing-App" window.location = new Point(40, 10) window.size = new Dimension(300, 200) window.visible = true Spiele etwas mit diesen Fenster-Eigenschaften, bis dir klar ist, wozu die einzelnen Werte gut sind. Ich werde diese Eigenschaften im folgenden nicht mehr jedes Mal hinschreiben. In jedem Programm solltest du nur ein Hauptfenster (MainFrame) haben. Ich zeige dir später, wie du zusätzliche Fenster erzeugen kannst. Das Spezielle am Hauptfenster ist, dass dein Programm beendet wird, wenn du das Fenster schliesst. DAS FENSTER AUSSCHMÜCKEN Das leere Fenster ist an sich noch nicht interessant. Wir setzen deshalb einige Elemente hinein. Allerdings kann ein Hauptfenster nur gerade

83 c 2013, Tobias Kohn Das Hauptfenster 81 ein Element enthalten. Wir setzen also eine»box«hinein, in die wir dann beliebig viele andere Elemente setzen können. Im nächsten Programm erzeugen wir zuerst eine Box (BoxPanel) und legen fest, dass der Fensterinhalt (window.contents) diese Box sein soll. Die beiden contents darunter (in den geschweiften Klammern) beziehen sich dann nicht mehr auf das Fenster, sondern eben auf die Für die GUI-Programmierung brauchst du in allen Programmen Box. Ein Label zeigt einfach den Text an, tut aber nichts. Button ist das Swing-Paket. Aus Platzgründen ist das entsprechende eine Schaltfläche, auf die du klicken kannst.»import swing._«hier nicht mehr jedes Mal angegeben. object MyFirstSwingApp { def main(args: Array[String]) { var window = new MainFrame window.title = "Meine erste Swing-App" window.contents = new BoxPanel(Orientation.Vertical) { contents += new Label("Hallo Welt") contents += new Button("Klick mich!") window.visible = true Probiere das Programm aus und füge weitere Label oder Buttons hinzu. Du kannst auch im BoxPanel die Orientierung auf Orientation.Horizontal ändern. Ein kleines Fenster mit einem Label, einem TextField und unten zwei Buttons. Damit die beiden Buttons nebeneinander stehen, liegen sie in einem eigenen Box- Panel, was aber nicht sichtbar ist. Ein BoxPanel ordnet alle Elemente entweder neben- oder untereinander an. Du kannst aber solche BoxPanels ineinander verschachtelt. Im nächsten Beispiel setzen wir unter den Text (Label) ein Eingabefeld (TextField) und zwei Schaltflächen nebeneinander. Mit border legen wir zudem einen Rand fest. window.contents = new BoxPanel(Orientation.Vertical) { border = Swing.EmptyBorder(10, 10, 10, 10) contents += new Label("Hallo Welt") contents += new TextField contents += new BoxPanel(Orientation.Horizontal) { border = Swing.EmptyBorder(5, 0, 0, 0) contents += new Button("Links") contents += new Button("Rechts")

84 82 Swing c 2013, Tobias Kohn Du kannst (musst aber nicht) bei jedem BoxPanel noch einen Rand festlegen. Die vier Zahlen geben den Rand jeweils links, oben, rechts und unten an. 7.2 FENSTER UND ELEMENTE Worin wir die wichtigsten GUI-Elemente zusammenstellen. Die folgende Tabelle stellt einige GUI-Elemente aus der Swing-Bibliothek zusammen. Die Liste ist nicht vollständig. Falls du im Internet nach weiteren Elementen suchst: Beachte, dass die Originalelemente aus Java meistens mit einem»j«beginnen (z. B. JButton oder JLabel). BoxPanel(ausrchtng) Button(text) CheckBox(text) ComboBox(liste) EditorPane Label(text) ListView(liste) TextField Eine Box, um mehrere andere Elemente zusammenzufassen und entweder untereinander (Vertical) oder nebeneneinander (Horizontal) anzuordnen. Eine Schaltfläche mit dem angegebenen Text. Der Benutzer kann mit der Maus draufklicken. Ein Kästchen mit oder ohne Häklein. Eine herausklappbare Liste, um ein Element auszuwählen. Ein mehrzeiliges Textfeld für grössere Eingaben. Stellt den (unveränderlichen) Text dar. Zeigt eine Liste an, aus der man ein Element aussuchen kann. In Java JList genannt. Ein einzeiliges Textfeld für Benutzereingaben. Die beiden Elemente ComboBox und ListView erwarten als Parameter jeweils eine Liste mit den Einträgen, die angezeigt werden sollen. Das Beispiel hier zeigt dir, wie du eine solche Liste angeben kannst. contents += new ComboBox(List("Adler", "Bison", "Chamäleon", "Dachs")) Wie du den Text aus einem Textfeld auslesen kannst, lernst du in einem der nächsten Abschnitte.

85 c 2013, Tobias Kohn Fenster und Elemente 83 WEITERE FENSTER* Falls du neben dem Hauptfenster noch weitere Fenster öffnen willst, dann verwendest du dazu nicht mehr MainFrame, sondern einfach Frame. object MultiWindowApp { def main(args: Array[String]) { var mainwindow = new MainFrame mainwindow.title = "Hauptfenster" mainwindow.visible = true var window2 = new Frame window2.title = "Zweites Fenster" window2.visible = true Mit dieser Technik kannst du so viele Fenster erzeugen, wie du brauchst. Der einzige Unterschied zwischen dem MainFrame und den anderen Frames ist der, dass du die anderen Fenster schliessen kannst, ohne dass das Programm beendet wird. Das Hauptfenster muss also immer offen sein, die anderen kannst du je nach bedarf sichtbar machen oder wieder verstecken. SELBER FENSTER DEFINIEREN** Dieser Abschnitt ist für diejenigen gedacht, die bereits Programmiererfahrung mit Java haben und wissen wollen, wie sie eigene Fenster in Scala kreieren können. In Bezug auf eigene Klassen musst für Scala zwei Dinge wissen: Erstens müssen Klassen in Scala nicht in einer eigenen Datei stehen. Du kannst so viele Klassen in eine Datei schreiben, wie du möchtest. Zweitens gibt es in Scala keinen eigentlichen Konstruktur. Code, der bei der Initialisierung (new) ausgeführt werden soll, wird direkt in die Klasse geschrieben. Und so sieht dann eine eigene Fensterklasse in Scala aus, die nur gerade einen Button enthält: class MyFrame extends Frame { var btn = new Button("Click me") contents = btn Alles, was nicht in einer Funktion (Methode) ist, gehört automatisch zum Konstruktur!

86 84 Swing c 2013, Tobias Kohn 7.3 AUF EREIGNISSE REAGIEREN Worin dein Programm auf Eingaben und Mausklicks reagiert. Als»Ereignis«(engl.»Event«) wird im Prinzip alles bezeichnet, was der Benutzer auslöst: Ein Mausklick, ein Tastendruck, eine Texteingabe, ein Fensterwechsel, etc. In deinem Programm kannst du selbst entscheiden, auf welche Ereignisse du überhaupt reagieren möchtest. MIT DER MAUS AUF EINE SCHALTFLÄCHE KLICKEN Das Programm unten ist so einfach wie möglich gehalten, reagiert aber trotzdem auf einen Mausklick. Zuerst einmal musst du neben dem üblichen swing-paket auch das swing.event-paket laden (darin sind alle Ereignisse angelegt). Der zweite wichtige Punkte ist, dass du die Schaltfläche (den Button) in einer Variable speicherst, hier btn1. Du brauchst die gleiche Schaltfläche nämlich an verschiedenen Stellen. Deshalb musst du sie speichern. import swing._ import swing.event._ Wiederum schreibe ich nicht mehr jedes Mal hin, dass du die beiden Pakete swing und swing.events laden musst. object ButtonClickApp { def main(args: Array[String]) { var window = new MainFrame var btn1 = new Button("Klick hier drauf!") window.contents = btn1 window.listento(btn1) window.reactions += { case ButtonClicked(_) => showmessage(message = "Geklickt!") window.visible = true Für die Reaktion auf das Mausklick-Ereignis brauchst du folgende Zutaten: window.listento(btn1) Mit der Anweisung listento gibst du an, dass die Schaltfläche btn1 ein Ereignis auslösen kann, das dich interessiert. Für jedes Element, das ein Ereignis auslösen darf, braucht es eine entsprechende listento- Anweisung.

87 c 2013, Tobias Kohn Auf Ereignisse reagieren 85 window.reactions += { case ButtonClicked(_) =>... Das Fenster hat bereits eine ganze Reihe von Reaktionen programmiert. Zu diesen Reaktionen fügst du damit eine neue Reaktion hinzu, und zwar auf das Ereignis ButtonClicked. Du kannst hier auch Code hineinschreiben, der z. B. den Text der Schaltfläche verändert: Viele GUI-Elemente haben die Eigenschaften foreground und background, um die Vorderbzw. Hintergrundfarben zu setzen. Die Farbe gibst du mit drei Werten für den Rot-, den Grün- und den Blau-Anteil an: ELEMENT.background = new Color(R, G, B) Die drei Farbwerte reichen von 0 bis 255. Dabei steht 0 für»schwarz«und 255 für»volle Helligkeit«. window.reactions += { case ButtonClicked(_) => btn1.text = "Gut gemacht!" btn1.foreground = new Color(120, 0, 0) Bei Color gibst du die Werte für die drei Grundfarben Rot, Grün und Blau (RGB) an. Farbwerte liegen von 0 bis 255. Die Kombination (120, 0, 0) ergibt ein dunkles Rot. Das Programm unten enthält ein Textfeld und eine Schaltfläche. Wenn du auf die Schaltfläche klickst, dann wird der Text, den du im Textfeld eingegeben hast, in einem Fenster ausgegeben. Du kannst also in einem ButtonClicked-Ereignis auch den Inhalt eines Textfelds auslesen. object ButtonClickApp { def main(args: Array[String]) { var window = new MainFrame var txtfeld1 = new TextField var btn1 = new Button("Klick hier drauf!") window.contents = new BoxPanel(Orientation.Vertical) { contents += txtfeld1 contents += btn1 window.listento(btn1) window.reactions += { case ButtonClicked(_) => showmessage(message = txtfeld1.text) window.visible = true Das Textfeld ist meistens ziemlich selbständig. Du musst also nicht auf Textfeld-Ereignisse wie»eine Taste gedrückt«reagieren. Um aber den Text auslesen zu können, musst du auch das neu erstellte Textfeld in einer Variablen speichern hier txtfeld1.

88 86 Swing c 2013, Tobias Kohn MEHRERE SCHALTFLÄCHEN Wenn du zwei oder mehr Schaltflächen hast, dann wird der Ereignis- Code ein wenig komplizierter. Das Beispiel unten zeigt dir, wie es aussieht. import swing._ import swing.event._ object ButtonClickApp { def main(args: Array[String]) { var window = new MainFrame var btn1 = new Button("Links") var btn2 = new Button("Rechts") window.contents = new BoxPanel(Orientation.Horizontal) { contents += btn1 contents += btn2 window.listento(btn1) window.listento(btn2) window.reactions += { case ButtonClicked(button) => if (button == btn1) showmessage(message = "Nach Links!") if (button == btn2) showmessage(message = "Nach Rechts!") window.visible = true Wie zu erwarten findest du im Programm jetzt zwei listento-anweisungen. Schliesslich dürfen beide Schaltflächen ein Ereignis auslösen und mitteilen, dass jemand drauf geklickt hat. Die grosse Änderung liegt im window.reactions-teil. Dort brauchen wir jetzt nämlich eine Möglichkeit, um die beiden Schaltflächen voneinander zu unterscheiden. Bei der ersten Version im letzten Abschnitt haben wir in case ButtonClicked in den Klammern nur einen Unterstrich geschrieben, was soviel heisst wie:»der Wert dort ist mir egal.«jetzt steht da ein button drin: window.reaction += { case ButtonClicked(button) =>... Das button ist eine Variable. Sobald du mit der Maus auf eine Schaltfläche klickst, speichert Scala automatisch in dieser button-variable, auf welche Schaltfläche du geklickt hast. Das machen wir uns zunutze und fragen mit einer IF-bedingung ab, ob es btn1 oder btn2 war.

89 c 2013, Tobias Kohn Auf Ereignisse reagieren 87 TEXT EDITIEREN Auch für Textfelder schauen wir uns ein Ereignis an:»valuechanged«wird immer dann ausgelöst, wenn sich der Text geändert hat. Das folgende Programm enthält ein Textfeld für Eingaben und ein Label, das Text nur anzeigen kann. Sobald du den Text im Textfeld änderst, wird auch der Text im Label angepasst. Die einzelnen Teile im Code dürften dir inzwischen bereits bekannt sein. import swing._ import swing.event._ Wozu braucht es das.text beim Eingabefeld? Scala akzeptiert ja auch: lbl1.text = textfeld1 Das Textfeld enthält eine ganze Reihe verschiedener Attribute: Position, Grösse, Farbe, Text, etc. Wenn du.text weglässt, dann bekommst du einen sehr langen String, der alles auf einmal enthält und meistens gar keinen Platz auf dem Bildschirm hat. Mit dem.text gibst du an, dass du nur den eingegebenen Text möchtest. object ButtonClickApp { def main(args: Array[String]) { var window = new MainFrame var txtfeld1 = new TextField var lbl1 = new Label("") window.contents = new BoxPanel(Orientation.Vertical) { contents += txtfeld1 contents += lbl1 window.listento(txtfeld1) window.reactions += { case ValueChanged(_) => lbl1.text = "Text: " + txtfeld1.text window.visible = true Sobald du mehrere Textfelder hast, wirst du unterscheiden müssen, welches sich nun wirklich geändert hat. Die Technik ist genau die gleiche wie bei mehreren Schaltflächen. Im Wesentlichen ändern sich nur der window.reactions-teil. Das könnte dann etwa so aussehen: window.reactions += { case ButtonClicked(_) => txtfeld1.text = "" // Textfeld leeren case ValueChanged(textfield) => if (textfield == txtfeld1) lbl1.text = "Text: " + txtfeld1.text Für jedes Ereignis brauchst du ein eigenes»case EREIGNIS() =>«. Bei jedem Ereignis kannst du in Klammern einen Unterstrich oder eine Variable angeben. Die Variable wird automatisch auf das Element gesetzt, das das Ereignis auch ausgelöst hat. Unterhalb des case prüfst du dann mit if, von welchem Element das Ereignis stammt und reagierst entsprechend darauf.

90 88 Swing c 2013, Tobias Kohn AUFGABEN 54. Mit text.reverse kannst du einen String text umdrehen. Bsp: scala> "Zebra".reverse res90: String = arbez Schreibe ein kleines Programm mit einem Eingabefeld und einer Schaltfläche. Wenn du auf die Schaltfläche klickst, dann wird der Text im Eingabefeld umgedreht. 55. Ein letztes Mal quadratische Gleichungen (siehe Seite 30). Schreibe ein Programm mit drei Textfeldern für die drei Zahlen a, b und c. Daneben hat dein Programm eine Schaltfläche. Wenn du mit der Maus daraufklickst, dann berechnet das Programm die Lösungen der quadratischen Gleichung mit den angegebenen Zahlenwerten. 56. Zurück zur Caesar-Verschlüsselung. Schreibe ein Programm mit zwei Textfeldern und zwei Schaltflächen. Das erste Textfeld enthält den Klartext (unverschlüsselt), das zweite Textfeld enthält den Geheimtext (verschlüsselt). Wenn du auf die erste Schaltfläche klickst, dann wird der Text vom ersten Feld verschlüsselt, wenn du auf die zweite Schaltfläche klickst, dann wird der Text vom zweiten Feld entschlüsselt und in das andere Textfeld geschrieben. 57. Programmiere ein Zahleneingabefeld. Dein Programm hat also ganz oben ein Textfeld. Darunter ist ein Zahlenblock mit den Ziffern 0 bis 9 aus einzelnen Schaltflächen. Wenn du auf eine dieser Schaltflächen klickst, dann wird die Ziffer automatisch an den Text im Textfeld angehängt. Du kannst dann also mit den Ziffern- Schaltflächen beliebige Zahlen eingeben.

91 c 2013, Tobias Kohn Die Taschenrechner-Oberfläche DIE TASCHENRECHNER-OBERFLÄCHE Worin wir die graphische Benutzeroberfläche für den Taschenrechner programmieren. Der kleine Taschenrechner, den wir hier programmieren, hat ein Eingabefeld, 16 Tasten und sieht etwa so aus wie im Bild links. In diesem Abschnitt erstellen wir diese Oberfläche und programmieren die Grundfunktionen, aber noch ohne das Rechnen. So könnte der kleine Taschenrechner etwa aussehen. Insgesamt wollen wir folgende Funktionalität für die Ziffertasten und den Punkt (die Operationen folgen später): Wenn du auf eine der Zahlen klickst, dann soll die Zahl ins Eingabefeld eingefügt werden. Falls das Eingabefeld eine»0«enthält, dann wird diese Null durch die neue Zahl ersetzt (die Eingabe soll dann also nicht»04«, sondern nur»4«sein. Auch der Punkt soll an die aktuelle Zahl angehängt werden. Allerdings nur, wenn die Zahl noch keinen Punkt enthält. DIE OBERFLÄCHE Der erste Schritt besteht darin, die ganzen GUI-Elemente zusammenzustellen und in das Fenster einzufügen. Der Code dazu sieht etwa so aus: import swing._ import swing.event._ object CalculatorApp { def main(args: Array[String]): Unit = { // Zuerst definieren wir alle GUI-Elemente: var window = new MainFrame var eingabefeld = new TextField() var btn0 = new Button("0") var btn1 = new Button("1") //... var btn9 = new Button("9") var btnpunkt = new Button(".") var btnadd = new Button("+") var btnsub = new Button("-") var btnmul = new Button("*")