Videoreihe: Programmieren lernen mit Lazarus
Transkript
Datentypen & Variablen
Bei diesem Video geht es um Datentypen und Variablen. Bevor wir uns die ersten Aufgaben anschauen, schauen wir uns erstmal so ein bisschen was zu Datentypen und Variablen im Allgemeinen halt an. Grundsätzlich Variablen sind Platzhalter für Werte, die gespeichert werden können. Kann alles Mögliche sein. Es können Strings sein, es können Integer-Werte sein, es können später ganze Objekte sein, die dort drin gespeichert werden. Ganz, ganz viele Sachen, die man halt speichern will und später nochmal verändern möchte, später nochmal drauf zurückgreifen möchte. Dafür nimmt man Variablen.
Variablen deklarieren
Wichtig in Lazarus ist halt, dass die Variablen einem Typ zugeordnet sind, die nicht per se ineinander überführt werden können. Also ich kann zum Beispiel, wenn ich eine Zahl deklariert habe vom Datentyp Integer, also eine ganze Zahl, dann kann ich dort keinen String reinschreiben. Da gibt es eine Fehlermeldung. Eine 5 kann ich reinschreiben, aber mit Anführungsstrichen, das ist ein String und dann gibt es halt eine Fehlermeldung.
Dann noch ein paar Begrifflichkeiten. Wenn ich also die Variable anlege mit diesem Keyword „var“,
macht man hier, dann nennt man das Deklaration. Also es kommt das Keyword, dann kommt der Name der Variable, Doppelpunkt, und dann kommt der Datentyp. Und eine Variable muss auf jeden Fall vor ihrer Benutzung initialisiert werden. Das bedeutet, ich muss irgendwann erstmal einen Wert dort reinschreiben, bevor ich auf die Variable zugreifen kann.
Datentypen
Dann seht ihr hier nochmal einen Überblick über die so wichtigsten Datentypen, mit denen man in der Regel arbeitet. Das Byte ist hier der Vollständigkeit halber aufgeführt, verwendet man eigentlich nicht so häufig.
Sehr häufig wird Integer verwendet, ist eine ganze Zahl, kann also auch eine negative Zahl sein. Hier ist dann das Beispiel für die Deklaration und ein Beispiel für eine Initialisierung. Und das ist der Bereich für den Integer-Datentyp, der nicht überschritten werden sollte, sonst könnte es zu Fehlern kommen, die man vielleicht auch nicht so leicht finden kann.
Single ist eine Gleitkommazahl, also einfach eine Kommazahl, aber eigentlich arbeitet man in der Regel mit Double-Kommazahlen. Wenn ich überhaupt schon eine Kommazahl nehme, dann nehme ich gleich Double. Das ist einfach eine höhere Genauigkeit. Und der Unterschied für die Reservierung des Speichers bei den beiden Datentypen ist jetzt bei unseren kleinen Projekten vollkommen irrelevant.
Char wird manchmal verwendet, ist ein einzelnes Zeichen. Wird hier so deklariert. Hier sieht man, wie man ein einzelnes Zeichen verwenden kann. Entweder als String mit einem einzelnen Zeichen oder aber auch, ich kann eine Zahl in einen Char übersetzen. Da gibt es eine Tabelle zu, das ist eine ASCII-Tabelle zum Beispiel. Dort sind jeder Zahl die Zeichen zugeordnet. Kann man also eine Zahl in ein Zeichen übersetzen, ist in dem Fall auch ein Plus. Strings haben wir schon mal gesehen, das ist eine Zeichenkette. Auch wieder mit Anführungsstrichen versehen. Dann ist das ein String.
Und dann gibt es noch einen Boolean-Wert. Das ist ein Wert, der entweder wahr oder falsch sein kann.
Wird meistens zum Vergleichen von irgendwelchen Bedingungen genutzt. Ist eine Bedingung wahr? Ist eine Bedingung falsch? Das sind Boolean-Werte.
Dann noch ein paar ganz allgemeine Hinweise. Grundsätzlich zu den variablen Namen, also ein Keyword, ist halt nicht erlaubt. Das ist meistens das, was in Lazarus auch schon fett gedruckt ist, sowas wie Begin oder Procedure. Das darf also keine Variablen Name sein. Variablen müssen auch mit einem Buchstaben oder einem Unterstrich beginnen. Meistens macht man aber das mit einem Buchstaben. Ich darf also keine Zahl am Anfang haben.
Variablen dürfen auch keine Leerzeichen besitzen. Da nimmt man dann halt einen Unterstrich, wenn man gerne ein Leerzeichen hätte. Eigentlich braucht man sowas grundsätzlich nicht. Man kann die Variablen einfach alle zusammenschreiben, selbst wenn es ein längeres Wort ist. Und dann kann man jedes neue Wort großschreiben. Das ist dann Camel-Case. Das ist so eine Konvention. Daran muss man sich nicht unbedingt halten. Ist ganz hilfreich, damit man den Überblick behält. Denn Variablen sollten auf jeden Fall, auf jeden Fall sprechend sein.
Also lieber ein bisschen eine längere Variable deklarieren, man weiß sofort, was es ist, als zu kurz und ich habe keine Ahnung, was mir die Variable sagen soll. Wenn ich jetzt sage Zahl der Schritte, dann sollte klar sein, okay, damit ist die Zahl der Schritte gemeint. Weil das ja klar ist. Deswegen lieber ein bisschen länger die Variablen haben. Ja, das ist erstmal das Wichtigste zu Variablen und dann schauen wir das Ganze mal konkret an der Aufgabe an.
Erste Aufgabe
Bei dieser ersten Aufgabe geht es darum, einmal ein Gedicht schreiben zu lassen. Nicht ganz wahr, das Gedicht ist schon ein bisschen vorgeschrieben, aber wir möchten das Gedicht anpassen können. Der Benutzer soll eine Farbe eingeben können und die wird dann in das Gedicht eingebaut. Also wenn ich jetzt blau eingebe und auf den Button klicke, dann kommt das Gedicht. Blaue Hüte, blaue Hosen, blaue Schrift auf blauen Dosen, blau erstrahlt in allen Ecken, will mich davon nur verstecken. Um dem Wahnsinn zu entgehen, dieses ganze Blau zu sehen, schlüpfe ich unter blaue Decken. Und wenn ich halt jetzt nicht blau eingebe, sondern von mir aus rot.
Dann soll halt kommen, ja, rote Hüte, rote Hosen, rote Schrift auf roten Dosen und so weiter. Je nachdem, welche Farbe eingegeben wird, kommt hier ein cooles neues Gedicht. Das machen wir jetzt also gemeinsam. So, ich habe hier schon ein bisschen was vorbereitet. Wir brauchen also für diesen Dichter, na gut, das Label brauche ich nicht unbedingt. Hier habe ich nochmal ein größeres Label. Man kann natürlich, um das ein bisschen zu vereinfachen, die Aufgabe einfach Wordwrap auf True stellen. Und dann wird das entsprechend immer über mehrere Zeilen geschrieben. Wenn ich aber selber steuern möchte, damit das Gedicht besser lesbar ist, wo die Zahlenbrüche sind, brauche ich hier kein Wordwrap. Das kann ich dann in dem Programm selbst machen. Ein Edit-Fenster. Ein Edit-Fenster finde ich hier oben in der Komponentenpalette. Das ist dafür da, dass der Benutzer eine Eingabe machen kann. Die Eingabe kann ich dann später in eine Variable. Die Variable einlesen und dann verarbeiten. Und dann haben wir einen Button, da passiert dann was.
Also starten wir einfach mal mit dem Programm. Wenn ich auf den Button klicke, soll jetzt als allererstes einmal das, was in dem Edit-Fenster steht, in eine Variable eingelesen werden. Deswegen brauche ich erstmal eine Variable. Die deklariere ich hier vor Beginn mit dem Keyword var und dann soll die Variable den Namen Farbe tragen. Das ist ein String, in dem Edit-Fenster ja auch ein String drin steht. Vor der ersten Benutzung muss ich die Variable initialisieren. Da muss ich also einen Wert reinschreiben. Und der Wert, den ich da reinschreiben möchte, der steht halt eben gerade in dem Textfeld von dem Edit-Fenster. Und das ist Edit1.Text. Es ist nicht wie bei einem Label oder wie bei dem Formblatt Caption. Frag mich nicht warum, weil es ist halt Text statt Caption. Okay, von mir aus. Übrigens, wo wir gerade dabei sind, kann man auch Kommentare in Lazarus machen. Ganz einfach, zwei Slash-Zeichen, startet ein Kommentar. Und dann kann ich irgendwas hinschreiben, zum Beispiel Farbe wird eingelesen.
Ich werde jetzt hier nicht immer so viele Kommentare schreiben, weil ich erkläre es ja. Wenn man aber den Code einfach nur schreibt, dann sollte man auf jeden Fall viele Kommentare schreiben, damit der Benutzer das Ganze auch verstehen kann. Ich kann auch mehrzeilige Kommentare machen mit so geschweiften Klammern. Da kann ich den ganzen Text reinschreiben. Hier wird aus. Weiter.
Okay, das also geht auch über mehrere Zeilen. Ich würde, wie gesagt, jetzt im Folgenden auf die Verwendung von Kommentaren eher verzichten.
Ich möchte das Ganze hier auf den Kern runterbrechen und ich erkläre es, wie gesagt. Als nächstes wollen wir ein Gedicht erstellen, das verändert werden kann. Und damit ich das verändern kann, brauche ich für das Gedicht auch eine neue Variable, nämlich das Gedicht, auch ein String. Und dort kann ich jetzt das Gedicht halt schreiben. Dann machen wir wieder mit dem Zuweisungsoperator, kann ich das Gedicht verändern. Und es geht halt los mit zum Beispiel blaue Hüte, blaue Hosen. Ich schreibe das erstmal so rein, wie wir es am Ende lesen wollen. Blaue Hüte, blaue Hosen. Jetzt wollen wir ja aber nicht, dass immer nur blaue Hüte, blaue Hosen kommen. Wenn ich das jetzt so speichern würde und einmal das Gedicht muss ich natürlich noch ausgeben, kann ich in dem Label ausgeben, sagen wir Label1.Caption, dann würde natürlich nur dieser Text kommen. Drücke ich drauf, kommt. Blaue Hüte, blaue Hosen. Nochmal, wir haben also…
Aus dem Edit-Fenster die Benutzereingabe eingelesen, schreibe sie in die Variable Farbe rein. Die haben wir aber noch gar nicht verwendet gerade. Dann kann ich das Gedicht erstellen als neue Variable, wo dann ein Gedicht reingeschrieben wird. Und dieses Gedicht, was ja ein Text ist, kann ich dann in das Caption von dem Label 1 reinschreiben. Aber es soll ja, je nachdem, welche Farbe eingelesen wurde, eine andere Farbe auch in dem Gedicht erscheinen. Und dafür verwendet man die Konkatenation von Strings. Das ist einfach nur ein Plus. Mit einem Plus werden Strings miteinander vereinigt. Und jetzt kann ich zum Beispiel sagen, ich nehme Farbe, Plus und dann der Text. Dann kann ich natürlich jetzt auf Blaue verzichten, weil ich habe ja jetzt die Farbe schon stehen. Je nachdem, welche Farbe eingegeben wird, kommt jetzt hier Rot, Güte, Blaue, Rosen. Machen wir ein Beispiel. Ich gebe Rot ein. Und dann kommt rot Hüte, blaue Hosen.
So, hier sehen wir schon, das liest sich so schlecht, weil wenn ich rot eingebe, fehlt ja noch ein E am Ende. Das muss ich also hier einfach mit dazu schreiben, das E. Außerdem auch wichtig, damit man es lesen kann, auch ein Leerzeichen, bevor wir das mit dem Hüten machen. Und genau das Gleiche mache ich jetzt bei diesem zweiten Vorkommen der Variablen auch. Wenn ich jetzt hier also auch rote Hosen, wenn das eingegeben wurde, haben möchte, muss ich den String beenden mit einem Anführungsstrich. Dann ist das jetzt hier der String. Der wurde hier einmal angefangen und einmal beendet. Dann konkateniere ich das, also ich verbinde die Strings.
In dem Fall wieder mit Farbe.
Und dann soll halt wieder ein E kommen für Rote. Und dann kommt Rosen.
Wenn wir das jetzt einmal probieren, haben wir schon ein ganzes Stück geschafft. Und wir haben, wenn ich hier rot eingebe, rote Hüte, rote Hosen. Das ist schon mal ein guter Start. Als nächstes möchte ich aber das Gedicht weiterschreiben. Und es soll ja aber über mehrere Zeilen gehen. Ich möchte also irgendwie einen Zeilenumbruch dann hinkriegen. Wenn ich das nicht mache, können wir mal schauen, wie das aussieht. Ich mache mal das Gedicht kurz ein bisschen weiter. Und dann gucken wir mal, wie das aussehen würde ohne Zeilenumbruch.
Okay, und dann sehen wir, das ist aber blöd, weil es wird über das Label hinausgeschrieben und ich möchte da schon irgendwie den Zeilenumbruch mit reinkriegen, damit man auch das Gedicht entsprechend von der Betonung auch richtig lesen kann, natürlich an der richtigen Stelle. Dafür gibt es auch eine Möglichkeit in Lazarus, nämlich mit S-Line-Break kann man einen Zeilenumbruch erzwingen. Das macht man auch wieder mit einem Plus und dort haue ich jetzt ein S-Line-Break sozusagen rein. Hier das Plus weg, dann mal so die Farbe plus Hüte, Farbe E plus Hosen, dann kommt der Zeilenumbruch, dann kommt wieder Farbe und dann kommt Schrift auf Farbe N Dosen. Das sieht ein bisschen blöd aus, aber ihr müsst euch immer überlegen, okay, wie sieht denn dieser String aus, wenn ich für Farbe zum Beispiel Rot einsetze. Dann haben wir rote Hüte, rote Hosen. Denn der Zeilenumbruch, rote Schrift auf roten Dosen, müsste also so weit passen. Probieren wir es mal, gebe ich jetzt hier rot ein.
Und wir haben rote Hüte, rote Hosen und dann kommt der Zeilenumbruch, rote Schrift auf roten Dosen.
Genau, also wenn ihr möchtet, könnt ihr das Gedicht einfach mal selbstständig noch vollenden. Wenn ihr nicht mehr genau wisst, wie das Gedicht lautete, könnt ihr nochmal kurz im Video zurückspringen, da war das ja. Ansonsten zeige ich euch jetzt einmal direkt die Lösung von dem gesamten Gedicht.
So, hier ist jetzt das Gedicht einmal vollständig und ein bisschen übersichtlich auch dargestellt. Immer dort, wo eine Farbe kommen soll, nutze ich jetzt die Variable, wo ich aus dem Edit-Fenster vom Benutzer eine Farbe eingelesen habe. Jetzt muss ich immer nur schauen, was hier noch ein Buchstabe fehlt, damit es halt lesbar ist. An den richtigen Stellen haue ich hier einen Line-Break rein und mit Plus kann ich die einzelnen Strings miteinander verknüpfen. Außerdem immer darauf achten, dass auch die leeren Zeichen mit dazu geschrieben werden, damit das Ganze lesbar bleibt. Und jetzt testen wir das Ganze auch einmal nochmal. Also, wenn ich das Gedicht hier fertig habe, dann wird es am Ende in dem Label ausgegeben. Label1.Caption, was soll da reingeschrieben werden? Das Gedicht. Okay, testen wir es nochmal. Blau passt. Blaue Hüte, blaue Hosen und so weiter. Rot geht auch wunderbar. Passt super. Grün.
Also auch mit Umlauten hat das keine Probleme. Es gibt aber manchmal Probleme, wenn ihr mit Lazarus arbeitet und ihr wollt da mit Umlauten was machen, gerade wenn ihr String-Verarbeitung verwendet. Das kann manchmal problematisch sein, also darauf achten, dass Umlaute, weil das im Amerikanischen nicht gängig ist, kann wie gesagt manchmal zu Problemen führen. Aber eigentlich schon relativ cool, mit so wenig Informationen, die wir eigentlich für das Programmieren gerade noch haben, dann doch schon so ein relativ cooles Programm zu schreiben, ganz am Anfang. Was hier vielleicht noch zu sagen ist, ist, das habe ich jetzt einmal vorausgesetzt, dass ich die Variablen hier auch mehrfach deklarieren kann. Ich kann also sagen, ich habe die Variable Farbe und dann sage ich ein Komma und eine weitere Variable, die ebenfalls vom gleichen Datentyp ist, die kann ich hier also mit einem Komma hintereinander fügen. Die sind also beide vom Typ String. Könnte ich auch lang aufschreiben, gerade bei verschiedenen Datentypen muss ich das sowieso machen mit einem Semikolon. Ich könnte auch sagen, Farbe ist ein String und das Gedicht, das ist auch ein String. Kann ich also so hintereinander schreiben. Ist natürlich dann ein bisschen länger und vielleicht nicht so schön. Bei verschiedenen Datentypen muss ich das auf jeden Fall so machen. Geht also auch so.
Wir haben zwar schon manchmal mit Variablen gearbeitet, aber es kann vorkommen, dass man doch einen Datentyp mal in einen anderen umwandeln muss. Das kommt meistens vor, wenn wir irgendwelche Daten von den Benutzern einlesen und dann irgendwie zum Beispiel aus einem Text eine Zahl machen wollen, damit wir damit rechnen können. Eine Übersicht über die wichtigsten Umwandlungsoperationen von einem Typ zu dem anderen Datentyp. Zum Beispiel, wenn ich eine ganze Zahl in eine Kommazahl umwandeln möchte, braucht man gar nichts machen. Also zum Beispiel kann ich eine Variable als Double-Variable deklarieren und kann trotzdem einfach eine 5 reinschreiben. Das geht natürlich ganz problemlos. Umgekehrt muss man doch ein bisschen was machen, von einer Kommazahl in eine Ganzzahl. Wenn ich eine ganze Zahl deklariert habe als Integer-Wert, kann ich da nicht einfach 1,23 reinschreiben. Da muss ich dann wirklich die Zahl vorher zum Beispiel runden, hier mit dem Befehl Round, kann auch die Nachkommastellen abschneiden. Es gibt auch andere Rundungsmethoden, kann man nochmal nachlesen, wenn man sich das nochmal genauer anschauen möchte.
Von einer ganzen Zahl in einen String. Das funktioniert mit der Methode IntToString. Beispiel, wir haben die ganze Zahl a deklariert, da schreibe ich zum Beispiel die Zahl 5 rein. Und wenn ich diese Zahl jetzt in einem Label ausgeben möchte, dann erwartet das Label ja für die Caption einen Text. Das heißt, ich muss diesen Integer-Wert in einen String umwandeln. Also IntToString und in der Klammer schreibt man dann da rein, was möchte man in einen String umwandeln. Ich kann auch einen String in eine ganze Zahl umwandeln, das funktioniert mit StringToInt. Ich kann zum Beispiel eine ganze Zahl deklarieren und dann kann ich zum Beispiel aus einem Edit-Fenster eine Benutzereingabe einlesen und die in diese Variable reinschreiben. Aber weil das ja ein Text ist, muss ich diesen Text vorher mit dieser Methode StringToInt in eine ganze Zahl umwandeln. Das klappt also auch alles mit Gleitkommazahlen, das heißt dann nicht mehr Int, sondern FloatToString.
Ansonsten ist es ganz genau das gleiche. Und man kann auch mit FloatToString f arbeiten. Da gibt es also noch zusätzliche Parameter, mit denen man also Rundungen noch angeben kann. Wenn man das mal benutzen möchte, dann müsste man sich mal die Dokumentation noch ein bisschen genauer anschauen. Ein Beispiel wäre hier eine Rundung auf vier Nachkommastellen mit diesen Parametern. Und ich kann auch ein String in eine Gleitkommazahl überführen mit StringToFloat. Ähnlich wie das auch mit StringToInt funktioniert. Das wollen wir mal an diesem Beispielprogramm hier üben. Das soll am Ende so aussehen, dass der Benutzer zwei Zahlen eingibt. Dann soll ganz einfach die Summe dieser beiden Zahlen berechnet werden und als Ergebnis an einem weiteren Label ausgegeben werden. Wer das gerne selbst probieren möchte, muss einfach hier das Video kurz pausieren. Und ansonsten kommt jetzt die Lösung.
Die Benutzeroberfläche ist hier also jetzt schon vorbereitet. Wir haben also zwei Edit-Fenster, jeweils für die beiden Eingaben vom Benutzer. Ein Button, der dann die Summe berechnen soll. Und wir brauchen auf jeden Fall ein Label, wo dann das Ergebnis auch reingeschrieben wird. Wenn ich also auf den Button klicke, soll es losgehen. Also starten wir mal die Button-Klick-Methode. Und dann brauchen wir als erstes mal zwei Variablen, in die wir die Benutzereingabe reinschreiben können. Also kommt das Keyword var für Variable. Und dann definieren wir einfach mal beispielhaft zwei ganze Zahlen. Den ersten und den zweiten Summanden.
Und die möchte ich jetzt aus dem Edit-Fenster einlesen. Und das Beispiel haben wir jetzt schon gesehen, so wie das funktionieren soll. Wenn ich das also nur so versuchen würde, direkt aus dem Textfeld des Edit-Fensters in den Summanden reinzuschreiben, dann gibt es eine Fehlermeldung. Wenn ich das versuche zu starten, kommt eine Fehlermeldung und da steht dann da Incompatible Types. Man erwartet also hier einen Integer-Wert und keinen String. Und demzufolge muss ich diesen Text erstmal in einen Integer-Wert umwandeln und das funktioniert mit StringTo Int. Und ganz genauso liest man also auch den zweiten Summanden ein. Kopiere ich hier einfach, kann dann die Beschriftung hier einmal ändern und wir lesen aus dem zweiten Edit-Fenster den zweiten Summanden ein.
Dann möchte ich das Ergebnis berechnen. Das Ergebnis von zwei ganzen Zahlen ist wieder eine ganze Zahl. Deklariere ich die Variable und das Ergebnis ist einfach nur Summand 1 plus Summand 2.
Und schließlich möchte ich das Ergebnis in dem zweiten Label ausgeben.
Wenn ich das wieder direkt versuchen würde, so auszugeben, gibt es wieder eine Fehlermeldung, weil wir haben ja hier wieder eine ganze Zahl stehen und hier erwartet Lazarus einen Text. Das funktioniert also so nicht. Er gibt also wieder einen Fehler und den Fehler behebe ich, indem ich diese ganze Zahl zunächst in einen String wieder zurück übersetze. Also IntToString.
Das Ergebnis wird in einen String übersetzt und das Ganze kann wir jetzt in einem Label ausgeben. Und so funktioniert das Programm dann. Ich kann jetzt hier zwei Zahlen miteinander addieren, 20 plus 32, 52. Und wir können das auch mit negativen Zahlen tatsächlich machen. Und dann kommt das passende, richtige Ergebnis raus. Das war dann die erste kleine Aufgabe, wo man das Umwandeln von Datentypen mal benutzt hat.
So, die nächsten beiden Programme sind einfach nur dafür gedacht, das Ganze einmal zu üben. Da gibt der Benutzer eine Temperatur ein in Grad Celsius und dann gibt es zwei Buttons. Einmal soll man das dann in Kelvin umwandeln und einmal in Grad Fahrenheit. Bei dem zweiten Programm, was zur Übung da ist, soll ein Startkapital, eine Laufzeit und ein Zinssatz eingegeben werden. Und dann ist es quasi einfach nur ein Zinsrechner mit Zinseszins-Rechnung. Und dann kann das Endkapital berechnet werden. Ich lege jetzt hier 3.000 Euro für vier Jahre zu 5% an. 5% aktuell stand jetzt nicht ganz unrealistisch. Wenn man hier Festgeldkonto irgendwo findet, teilweise aufs Tagesgeld, gerade im Moment sogar 4%, da findet man sicher was Schönes. Kriegt man immerhin nach vier Jahren 3.646 Euro raus.
Äh, was? Es ist weg, es ist alles weg. Was ist weg? Das Geld auf deinem Konto. Es lief nicht so gut. Es ist weg. Ja, und das soll hier auch einmal selbstständig programmiert werden. Die, die das selber probieren möchten, habe ich einmal beide Formeln hier abgedruckt. Könnt ihr also hier verwenden. Ihr müsst aber, wenn ihr die Power-Funktion für die Potenz einer Zahl verwenden wollt, die Unit Math einbinden. Und wer das nicht ganz genau weiß, kann das auch recherchieren. Oder ihr guckt euch jetzt die Lösung an.
So, erstes Programm, der Temperatur-Umwandler. Wir haben ein Edit-Fenster zur Eingabe, wir haben zwei Label, Label 1 und Label 2, für die Ausgabe und wir haben zwei Buttons, die die Eingabe in die entsprechenden Temperaturen umwandeln und dann ausgeben. Fangen wir doch einmal an mit der Temperaturumwandlung von 40°C oder von irgendeiner Celsius-Gradzahl in Kelvin. Wir brauchen also erstmal eine Variable, die die Grad-Celsius-Zahl hier einliest.
Das soll also hier eine Kommazahl sein.
Aus dem Edit-Fenster lese ich jetzt diese Celsius-Grad-Zahl ein. Wieder dabei aufpassen, das ist ein Text, also ein String, und man muss diesen String erstmal in eine Kommazahl übersetzen mit String to Float. Und das Ergebnis der Rechnung soll dann in die Variable Kelvin reingeschrieben werden. Und die Rechnung ist ganz einfach. Man muss einfach nur 273 zu Celsius addieren und schon hat man die Kelvin.
Das Ganze geben wir jetzt noch in einem Label aus. Und auch hier muss ich die Kommazahl erst wieder in einen Text übersetzen. Und das funktioniert eben mit FloatToString. Und da gebe ich jetzt ein, was ich in einen String übersetzen möchte, und das ist halt Kelvin. Das Ganze können wir jetzt mal testen. Am besten testen wir das mal mit 0 Grad, da wissen wir nämlich, was rauskommt. Das sind 273 Kelvin. Und bei 10 Grad Celsius sind das 283 Kelvin. Gut, das funktioniert natürlich jetzt so.
Ähnlich auch mit der zweiten Aufgabe. Damit ich nicht nochmal alles neu schreiben muss, kopiere ich jetzt die Kommazahl. Großteil und ändere einfach entsprechend ab, was sich hier tatsächlich ändert. Wir haben also jetzt nicht mehr Keldin, was wir überrechnen wollen, sondern wir haben Fahrenheit und die Celsius lese ich nach wie vor genauso ein, nur die Formel ändert sich natürlich. Die Formel habt ihr ja gerade gesehen, das ist 9 Fünftel mal Celsius plus 32.
Und in dem Label, da geben wir jetzt also nicht mehr Kelvin aus, sondern Anheit. Und wir können auch mal üben, jetzt das Ganze ein bisschen zu runden, weil wenn ich das jetzt einmal so ungerundet ausgeben würde, so wie das jetzt hier steht, sagen wir mal, wir wollen 33,333 Grad Celsius und fahren hier halt umwandeln und dann kommt dann eine relativ lange Kommazahl raus und ich kann das Ganze also auch hier runden und dann sagen wir halt FloatToString f und die Parameter hier sind ffNumber, die wir für die Zahl brauchen, die Präzision, wir wollen insgesamt 8 Ziffern ausgeben und zwar 2 Nachkommastellen.
Bei der gleichen Eingabe kommt jetzt der gerundete Wert von 92 raus. Gut, das war jetzt also das erste Programm.
Schauen wir uns da mal das zweite Verzinsungsprogramm an. So, wir haben drei Eingabefenster, jeweils für das Startkapital, Laufzeit und Zinssatz. Wir haben einen Button zur Berechnung und ein, was ist das, ein Label, Label 5, für die Ausgabe des Endkapitals. Natürlich, wenn ich drei Eingabefenster habe, möchte ich natürlich auch diese drei Werte vom Benutzer eingeben lassen. Ich brauche also auf jeden Fall drei Variablen, die wir eingeben. Das ist einmal das Startkapital.
Und wir müssen auch den Zinssatz einlesen, das sind beides Kommazahlen.
Und für die Laufzeit, da geben wir jetzt mal eine ganze Zahl an. Und alles müssen wir natürlich wie gewohnt mit String to Float bzw. mit String to Int aus den Edit-Fenstern einlesen.
Nachdem wir alle Variablen initialisiert haben mit den Eingaben des Benutzers, können wir jetzt die Rechnung starten. Die Rechnung ist Startkapital mal 1 plus p hoch n. Starten wir erstmal damit, dass wir eine Variable für das Endkapital deklarieren. Das ist also auch ein Double-Wert. Das Startkapital soll multipliziert werden.
Mit 1 plus p hoch n. Aber dieses hoch n, so klappt es tatsächlich nicht. Da gibt es also eine extra Methode. Und diese Methode nennt sich Power. Mit der kann ich also die Potenz, die n-te Potenz berechnen. Also Power. Das erste Argument für diese Methode ist halt die Basis. Und das zweite Argument ist der Exponent. Das ist n. Leider klappt es jetzt, so wie es hier steht, nicht. Wenn ich das Ganze versuche zu starten, Identifier not found, Power erkennt diese Methode nicht. Und das liegt daran, dass das in den Standardbibliotheken, die zu Beginn hier eingebunden sind, nicht vorkommt. Das wird also von Lazarus hier alles automatisch angelegt. Hier sind ein paar Standardbibliotheken mit den wichtigsten Methoden, die man so braucht. Aber Power kommt in der Unit Math vor. Und die müssen wir halt extra noch einbinden. Das kann ich hier ganz einfach mit einem Komma. Da gibt es also eine Bibliothek, die heißt so. Und die kann ich dann also nach Uses hier mit einem Komma zusätzlich einbinden. Und dort steht also auch drin, wie diese Methode hier Power vorliegt. Und dann kann ich sie jetzt verwenden. Und dann kann ich sie jetzt verwenden.
Ich muss natürlich das Ganze noch richtig schreiben, sonst wird das natürlich auch nichts. Hier haben wir ein paar Schreibfehler drin.
Aber jetzt sollte das Ganze funktionieren. Es gibt also jetzt keine Fehler mehr, aber natürlich haben wir noch keine Ausgabe. Das Endkapital wird jetzt also in Label 5 ausgegeben.
Ich habe jetzt hier wieder FloatToString F verwendet, aber ihr könnt auch ganz einfach nur Flow to String angeben und dann klappt das genauso und dann braucht ihr auch diese ganzen Parameter hier nicht. Um das Ganze natürlich zu testen, würde man hier vielleicht ein paar leichtere Werte eingeben, um erstmal zu schauen, ob das Programm überhaupt funktioniert. Ich lasse es mal für ein Jahr zu 5% hier liegen und dann haben wir 1050 Euro nach dem ersten Jahr. Beziehungsweise, wenn ich das Ganze zwei Jahre liegen lasse, haben wir 1102,50 Euro gegen den Zinseszins. Gut, klappt doch super. Jetzt habt ihr mal gesehen, wie man Nutzeingaben verarbeiten kann und auch wieder zum Beispiel in einem Label ausgeben kann.
Okay, in diesem Abschnitt geht es um globale Variablen und da machen wir mal ein ganz einfaches Beispielprogramm dazu. Kennen wahrscheinlich die meisten so eine Art Cookie-Clicker, aber die einfachste Version davon. Ich klicke einfach auf den Cookie und dann kann ich Kekse sammeln. Und wenn ich öfters draufklicke, kriege ich halt mehr Kekse. Oh, man bin ich jetzt wieder froh, ich habe Kekse. Also wirklich ganz, ganz einfaches Programm. Kann man dieses Konzept der globalen Variablen super erklären, deswegen machen wir das genau hier ran. So, für die Lösung des Programms habe ich hier schon was vorbereitet. Und zwar brauchen wir ein Image und das findet ihr bei Additional. Dann ist das das hier, diese Komponente Image. Da könnt ihr Bilder reinladen. Hier ist jetzt schon ein Keks drin. Wir brauchen zwei Labels. Übrigens findet ihr alle Materialien und alles vorbereitet und alle Musterlösungen und alles verschriftlicht auch nochmal unten für dieses Video in der Videobeschreibung oder für die komplette Sequenz. Könnt ihr mich finanziell ein bisschen unterstützen, wenn ihr mögt. Oder ihr lasst einfach ein Like da und einen Kommentar. Dann würde ich mich auch super drüber freuen. Vielen Dank.
Wenn wir jetzt also auf den Keks klicken, soll sich der Keks-Counter erhöhen. Deswegen wählen wir einmal diese Image-Komponente an. Dann schauen wir hier links bei dem Reiter Ereignisse. Da haben wir ein Ereignis onClick. Also auch ein Image hat das Ereignis onClick. Da kann ich draufklicken. Da wird das ausgelöst. Wenn ich das hier mal mache, doppelt draufklicke, wird dann automatisch dieses Image1-Klick-Ereignis von Lazarus erstellt. Und an dieser Stelle soll ja ein Cookie-Counter erhöht werden. Jetzt könnte ich ja überlegen, naja, dann machen wir das ganz einfach. Vielleicht eine Variable, sagen wir mal Anzahl Kekse. Und dann möchte ich ja diese Anzahl der Kekse erhöhen. Also sage ich Anzahl Kekse wird Anzahl Kekse plus 1. Und wenn man das so versuchen würde, da sind ein paar Fehler drin.
Ein paar kleine Probleme, die wir hier aus dem Weg rollen müssen. Und zwar das erste. Wir haben hier eine lokale Variable. Das bedeutet, die Variable wird angelegt, sobald diese Image-Klick-Methode ausgeführt wird. Aber nachdem diese Methode abgeschlossen wird, existiert diese Variable nicht mehr. Das heißt, das Programm weiß auch gar nicht mehr, was vorher da für eine Zahl drinne stand. Wenn ich also nochmal neu draufklicke, ist es quasi wieder null und nichtig. Und das nächste, ich müsste diese Variable ja einmal initialisieren, bevor ich sie verwenden kann. Ich kann sie ja erst um 1 erhöhen, wenn da vorher eine Zahl drinne stand. Allerdings, wenn ich versuchen würde, die in der Methode selbst zu initialisieren, dann würde diese Methode ja beim Aufruf diese Variable immer erst mal 0 setzen und dann um 1 erhöhen. Da steht ja immer erst mal nur 1 drin. Wir können das gerne mal probieren.
Da würde ich also mal versuchen, das Ganze in dem Label auszugeben. Da das Label wieder einen Text erwartet, also einen String, muss ich diese Integer-Variable erstmal in einen String umwandeln mit IntToString. Wenn ich jetzt auf den Keks klicke, dann wird die Anzahl der Kekse immer 1 sein, egal wie oft ich da drauf klicke. Wie gesagt, anfangs beim Ausführen der Methode wird das auf 0 gesetzt, dann um 1 erhöht. Das ist immer 1. Wie behebe ich dieses Problem jetzt?
Wir müssen aus dieser lokalen Variable eine globale Variable machen, die überall und immer im Programm verfügbar ist und auch nicht einfach wieder gelöscht wird, sobald die Methode abgearbeitet wird. Und der Trick ist, die Variable also hier oben vor Implementation anzulegen. Dort werden alle globalen Variablen angelegt, die für die gesamte Unit bekannt sind. Das heißt, ich kann das Ganze da oben einfach mal reinschreiben. Und das ist jetzt also eine globale Variable. Die brauche ich dann hier unten also nicht nochmal neu deklarieren.
Und das zweite Problem ist, ich muss ja diese Variable erstmal initialisieren. Ich muss ja am Anfang irgendwie 0 reinschreiben, das wir am Anfang noch nicht draufgeklickt haben. Und dann erst, wenn ich auf das Image draufklicke, soll die Variable jedes Mal wieder neu um 1 erhöht werden. Und dafür gibt es in Lazarus eine interessante Methode.
Das ist die FormCreate-Methode. Wir können also mal auf das Formblatt klicken. Und da haben wir bei Ereignisse das Ereignis OnCreate. Oder ich kann auch doppelt auf das Formblatt draufklicken, dann wird dieses Ereignis … auch angelegt. Diese OnCreate-Methode wird immer dann aufgerufen, sobald das Programm gestartet, also das Formblatt erzeugt wird. Und an dieser Stelle kann ich jetzt die Anzahl der Kekse initialisieren und einmal auf den Wert 0 setzen.
Das bedeutet, sobald dieses Formblatt erstellt wird, das Programm gestartet wird, wird diese Anzahl auf 0 gesetzt, einmalig und anschließend kann ich mit dieser Anzahl arbeiten und diese alte Anzahl um 1 erhöhen und sie dann in die Variable reinschreiben, also den Wert überschreiben. Es spielt übrigens keine Rolle, dass die FormCreate-Methode nach der ImageClick-Methode im Programmcode steht. Die wird ja beim Erzeugen des Programms aufgerufen, das heißt die Reihenfolge, wie sie hier im Text steht, spielt hier keine Rolle. Wen das aber stört, den kann man natürlich hier das Ganze auch nochmal verschieben ein bisschen, dass die FormCreate-Methode sollte ja vom logischen eher am Anfang des Quellcodes stehen. Das macht es, glaube ich, besser verständlich.
Starte ich jetzt das Programm, dann funktioniert das Ganze. Immer wenn ich auf den Keks klick, wird die Anzahl der Kekse um 1 erhöht. Und selbst wenn die Methode image1click abgeschlossen wurde, ist die Variable Anzahl der Kekse immer noch erhalten und der Wert wird auch weiter gespeichert, weil es eine globale Variable ist.
Also hier habt ihr dann den Unterschied noch mal kennengelernt zwischen lokalen und globalen Variablen. Ihr müsst euch also immer überlegen, was ihr für eine Variable braucht, ob ihr sie nur innerhalb der Methode einmalig verwenden möchtet oder soll sie während des Programmablaufs für das gesamte Programm erhalten bleiben.
Ja, für diese letzte Aufgabe sollt ihr ein Programm schreiben, wo die Quersumme einer Zahl berechnet werden soll. Damit es nicht zu schwierig wird, soll die Zahl maximal vier Stellen besitzen. Also ein Beispiel. Die Quersumme von 12 ist 3. Dafür werden einfach die beiden Ziffern 1 und 2 addiert. Also 1 plus 2 sind 3. Und ein anderes Beispiel. Die Quersumme von 46 ist 10. Weil 4 plus 6 sind 10. Und wenn ich jetzt zum Beispiel noch eine Ziffer hinzufüge, die 465, davon die Quersumme, das ergibt 15. Das ist das Programm. Um das Programm gut lösen zu können, brauchen wir eine zusätzliche Methode. Das ist die Modulo-Methode. Und da machen wir mal ein Beispiel dazu. Also 7 durch 3 ist 2. Rest 1. Ja, die 3 passt zweimal in die 7. Aber da bleibt ja noch ein Rest übrig. Und diesen Rest kann man mit Modulo auswählen. Das heißt, 7 mod 3 ist dann 1. Also Mod gibt den Rest bei einer ganzteiligen Division aus. Anderes Beispiel, 12 durch 4 ist 3, Rest 0. Und demzufolge ist dann 12 Modulo 4 0. Und ein letztes Beispiel, das brauchen wir also bei dieser Quersumaufgabe, wenn wir mit 10 dividieren. 345 durch 10 ist 34, Rest 5. Und dann, wenn ich das Modulo rechne, haben wir 345 Modulo 10, ist dann demzufolge 5. Wenn ihr diese Modulo-Funktion habt, könnt ihr einfach mal selber probieren, diese Aufgabe zu lösen. Da einfach mal das Video pausieren. Ansonsten kommt jetzt hier die Lösung.
Okay, die Benutzeroberfläche ist relativ einfach gehalten. Wir haben ein Eingabefenster für die Zahl, für die wir die Quersumme berechnen wollen, dann einen Berechnen-Button und ein Label, die Quersumme, wo das dann ausgegeben wird. Klicken wir mal auf den Berechnen-Button, dann soll also das Ganze losgehen, die Berechnung. Und da legen wir als erstes einmal ein paar Variablen an. Einmal natürlich die Variable für die Eingabe.
Wir lesen also aus dem ersten Edit-Fenster die Eingabe vom Benutzer ein und schreiben sie in diese Variable Eingabe rein. Wenn ich jetzt also die Quersumme von einer solchen Zahl berechnen möchte, da brauche ich ja die einzelnen Ziffern. Einfachsten ist es, wenn man versucht, die letzte Ziffer erstmal zu isolieren und die rauszukriegen. Das kriegt man halt eben mit Modulo 10. Die letzte Ziffer nenne ich jetzt mal Ziffer 4, weil wir eine Zahl haben, die maximal 4 Stellen besitzt. Das kriege ich jetzt also, indem ich einfach die Eingabe Modulo 10 rechne.
Die Frage ist jetzt, wie kriegt man dann jetzt die vorletzte Ziffer? Ja, wie kann man das machen? Zum Beispiel, indem man bei der Eingabe einfach die letzte Ziffer rausschmeißt sozusagen. Ich kann also die Eingabe einfach durch 10 teilen und dann könnte ich sie abrunden. Dieses durch 10 teilen und abrunden kann man ganz einfach mit dem div-Command machen. Das ist also eine ganzzahlige Division und dann meckert er auch nicht, dass diese beiden Variablen Integer-Variablen sind. Ich teile durch 10 und runde. Ich teile gleichzeitig ab. Dadurch wird also der letzte Teil von der Zahl rausgeschmissen. Die letzte Ziffer wird quasi rausgeschmissen. Wir haben also jetzt eine Zahl, die um eine Stelle kürzer ist und haben jetzt also die vorletzte Ziffer an der letzten Stelle stehen. Das heißt, ich kann genau das gleiche jetzt nochmal machen. Die Ziffer 3 bekomme ich also wieder, indem ich die Eingabe Modulo 10 rechne. Und dann wiederhole ich das Ganze einmal so lange, bis ich jede einzelne Ziffer isoliert habe. Ich gehe das hier also einmal ein paar Mal.
Und dann sollte ich an dieser Stelle jede einzelne Ziffer einmal rausgefunden haben. Ich habe also vier Ziffern als Variablen angelegt. Und jedes Mal, wenn ich die letzte Ziffer durch Modulo 10 rausbekommen habe, teile ich durch 10 Runde ab. Dann ist die letzte Ziffer raus und ich kann wieder die letzte Ziffer der neuen Zahl mit Modulo 10 rausfinden. Das kann ich vielmehr machen. Das klappt übrigens auch, wenn die Zahl kürzer ist und nicht vier Stellen besitzt. Weil, wenn zum Beispiel die Zahl nur zwei Stellen besitzt und ich teile durch 10 Runde ab, irgendwann ist die Zahl dann 0, dann stehen halt in Z2 und Z1 Nullen drin. Das ist für die Quersumme-Berechnung also nicht so schlimm. Das kann man natürlich später ein bisschen eleganter lösen, dass man das für beliebig lange Zahlen macht. Da brauchen wir aber Schleifen zu. Das können wir also jetzt noch nicht. Aber für maximal vierstellige Zahlen klappt das natürlich jetzt. Als letztes müssen wir natürlich noch die Quersumme selbst berechnen. Wir haben die einzelnen Ziffern jetzt rausgefunden. Und die Quersumme ist ja einfach nur die Summe aller Ziffern.
Das heißt, ich lege eine neue Variable Summe an und addiere jetzt einfach alle diese einzelnen Ziffern.
Das Ganze muss ich natürlich noch in einem Label ausgeben. Das habe ich hier lAusgabe genannt. Und dann sollte das Programm jetzt funktionieren. Wir berechnen die Quersumme von 345 bis 12. Vielleicht auch mal von einer zweistelligen Zahl. Quersumme ist 5. Von einer einstelligen Zahl. Quersumme ist 6. Oder von einer vierstelligen Zahl. Die Quersumme ist 12. Wunderbar, so ist das also.
Jetzt habt ihr also gesehen, wie man mit Variablen arbeitet. Aber auch, wie man Variablen einlesen kann vom Nutzer. Wie man die Datentypen umwandeln kann, damit diese Eingabe funktioniert. Wie ich dann die Variablen für Rechnungen verarbeiten kann. Und auch wieder ausgeben kann, dass man sieht, was bei der Rechnung dann eigentlich passiert ist.
Danke fürs Zuschauen. Und ich hoffe, ich sehe euch dann beim nächsten Video wieder reinschauen.