Willkommen zur Videoversion der ersten Übung.
Sie beginnt im Begrüßungsfenster von IntelliJ,
wo wir zu Beginn ein neues Projekt erstellen.
Es handelt sich um ein Java-Projekt und im
nächsten Schritt geben wir ihm einen Namen,
in meinem Fall Uebung1.
Mit Enter oder Finish wird daraufhin das Projekt
erstellt.
Nun navigiere ich zum Source-Ordner des Projektes
und kann mit einem Rechtsklick eine neue Java-Klasse
erstellen.
Als Namen wähle ich HelloWorld und drücke
Enter.
Und jetzt wurde eine Klasse erstellt, in deren
geschwungenen Klammern wir unser Programm
schreiben können.
Allerdings fehlt noch eine Main-Methode die
wir mit dem Kürzel für public static void
main und Enter unkompliziert erstellen können.
Innerhalb der geschwungenen Klammern können
nun die Anweisungen eingefügt werden.
Für die erste nutze ich den Shortcut „sout“
und drücke Enter.
Vervollständigt wird dann System.out, an
die ein Text in Anführungszeichen übergeben
wird, welcher auf der Konsole ausgegeben werden
soll.
Zum Ausführen des Codes bietet sich der grüne
Pfeil an und tatsächlich wird in der Konsole
die Meldung „Hello World“ ausgegeben.
Ändere ich Hello World in einen Integer wie
z.B. 42 benötige ich keine Anführungszeichen.
Der nächste Schritt ist nun die Deklaration
von Variablen, es wird also Platz im Arbeitsspeicher
reserviert.
Definiere ich z.B. einen Integer, werden 32
Bit für den Wert der Variable bereitgestellt.
31 Bit stehen für den Betrag zur Verfügung
und das 32ste gibt das Vorzeichen an.
Für den Fall, dass diese Erklärung zu kompakt
erscheint, kann ich als ausführliche Version
das Video „Representing Numbers and Letters
with Binary“ aus der Serie Crash Course
Computer Science empfehlen.
Für Fließkommazahlen reicht der Integer
nicht mehr aus, deshalb definiere ich einen
Double und für Text schließlich noch einen
String, der groß geschrieben wird, weil es
sich um ein von Java zur Verfügung gestelltes
Objekt handelt, welches nicht mehr einfach
nur 32 feste Bits benötigt, sondern mehrere
Buchstaben zu einem Text kombiniert.
Wie schon bei dem Sysout erfordert auch der
String Anführungszeichen.
Anschließend gebe ich die Werte im Sys-Out
aus.
Dafür nutze ich entweder einen separaten
Aufruf, bei dem jede Variable einzeln ausgegeben
wird oder kombiniere die Werte in einem einzigen
Sys-Out, indem ich ein + zwischen die einzelnen
Parameter setze.
Anschaulicher wird es nun noch, wenn ich zwischen
die Werte Kommas einfüge und dann wieder
den Code mit dem grünen Pfeil oder Shift+F10
als Shortcut ausführe.
Als nächstes sollen nun die Zahlen von 1-10
auf der Konsole ausgegeben werden.
Der naive Ansatz wäre hierbei, schlicht und
einfach 10 Sys-Out-Aufrufe einzufügen und
den Parameter manuell zu verändern, allerdings
wird diese Vorgehensweise bei steigendem Endwert
zunehmend ineffizient.
Eine bessere Lösung bietet die For-Schleife,
deren Template mit dem Shortcut „fori“
erzeugt wird.
Innerhalb der Forschleife wird eine Indexvariable
i deklariert und ihr Wert wird mit Sysout
ausgegeben.
Im Anschluss wird der Wert für i um 1 erhöht,
dafür steht das „i++“.
Dies geschieht so lange, bis i den Wert 10
erreicht.
Führen wir den Code aus, werden wie erwartet
die Zahlen von 1 bis 10 ausgegeben.
Schleifen gehören zum Grundrepertoire eines
Computers und im Endeffekt ist es für ihn
ein Kinderspiel aufsteigend in binären Zahlen
zu zählen bis der Wert von zwei Speicheradressen
gleich ist.
Um genau diese Überprüfung von zwei Werten
geht es auch im nächsten Beispiel.
Wenn der Wert der statischen Unbestimmtheit
größer als 0 ist, soll das System erkennen,
dass es überbestimmt ist, bei 0 ist es statisch
bestimmt und ansonsten unterbestimmt.
Zur Umsetzung in Java nutze ich dafür if-Statements,
deren Shortcut „ifn“ ist.
Davor muss ich allerdings noch eine Variable
für die statische Unbestimmtheit deklarieren.
Ist sie größer als 0 folgt in den geschwungenen
Klammern des Ifs der Sys-Out für überbestimmt,
es beginnt mit einem Text, dann dem genauen
Grad und schließlich ein abschließender
Text wieder in Anführungszeichen.
Ist der Grad stattdessen gleich 0 greift nach
der schließenden Klammer die else-if-Anweisung.
Da ein einzelnes „=“ bereits für die
Deklarierung für Variablen gebraucht wird,
ist hier ein doppeltes „=“ erforderlich.
Wieder folgt der entsprechende Sysout mit
der Antwort und ein weiterer if-else-Block
für den Fall, dass der Wert negativ ist.
Führe ich im Anschluss das Programm für
beispielsweise den Wert 23 aus, erhalte ich
23-fach unbestimmt als Anwort, bei 0 statisch
bestimmt, allerdings für „-5“ „-5-fach"
statt "fünfach verschieblich".
Gelöst wird das Problem entweder mit einem
Minus oder der von Java bereitgestellten Methode
"Math.Abs", welche den Betrag des Inputs zurückgibt.
In der nächsten Aufgabe kombinieren wir nun
for-Schleife und if-Statements für einen
Brute-Force-Passwort-Check-Mechanismus.
Wir beschränken uns in diesem Fall auf eine
PIN bestehend aus Zahlen, in der Praxis ist
es aber nicht weiter schwer, Zahlen in Buchstaben
umzuwandeln, es gibt dafür die ASCII-Tabelle,
nach der unverschlüsselt kodiert wird.
Speichere ich z.B. eine Textdatei mit dem
Inhalt ABC auf der Festplatte und öffne die
Datei mit einem Hex-Editor sehe ich, dass
dort einfach nur drei Zahlen gespeichert wurden.
Zurück in IntelliJ definiere ich zuerst eine
Variable für die zu erratene PIN und darauf
folgt dann eine For-Schleife, die jede mögliche
Pin durchgeht.
Für den Fall, dass die PIN mit der Indexvariable
i übereinstimmt, wird ein Sysout mit i ausgegeben,
ansonsten erscheint eine Meldung für die
falsche PIN.
Führen wir nun das Programm aus, wurde für
jeden Durchlauf der Schleife die PIN überprüft
und bei der richtigen auch tatsächlich das
Ergebnis ausgegeben.
Effizienter wird die Schleife außerdem noch,
indem ich im Erfolgsfall einen „break“
nach dem Sysout einfüge, dann wird der Durchlauf
der Schleife sofort abgebrochen und Rechenleistung
gespart.
Führe ich das Programm jetzt erneut aus,
sehe ich, dass in der Tat nach der gefunden
PIN keine weiteren Meldungen mehr auf der
Konsole auftauchen.
In der letzten Aufgabe geht es schließlich
noch darum, die als String vorliegende PIN
in einen Integer zu konvertieren.
Als Beispiel definiere ich je einen Integer
und einen String mit dem Wert 42.
Möchte ich diesen Wert primitiv verschlüsseln,
indem schlicht und einfach der geheime Schlüssel
11 dazuaddiert wird geht das für den Integer
sehr einfach, weil die +11 direkt dazugeschrieben
werden kann.
Als Ergebnis kommt wie erwartet 53 heraus.
Ersetze ich die Integer- durch die String-Variable
wird jedoch erst die 42 und dann die 11 ausgegeben,
weil zwei verschiedene Datentypen nicht einfach
addiert werden können.
Um Datenwerte umzuwandeln, gibt es vorgefertigte
Funktionen wie Integer.parseInt(), die einen
String in einen Integer konvertiert.
Und nutze ich diese Funktion für die String-Variable,
wird auch dort endlich der Wert 53 ausgegeben.
Angewandt auf die Passwort-Funktion aus Aufgabe
5 wird dieses Mal die Variable als String
gespeichert und im weiteren Verlauf mit parseInt
in einen Integer umgewandelt.
Der restliche Code bleibt unverändert.
Wie ein Kochrezept im analogen Kochbuch muss
auch der Code physisch auf der Festplatte
gespeichert werden.
In meinem Fall ist das in der IntelliJ-Installation
der Ordner Uebung1 und unter src befindet
sich die HelloWorld.java.
Öffne ich eine java-Datei in einem Hexeditor,
sieht man klar, dass in Nullen und Einsen
auf der Festplatte genau der Code gespeichert
ist, welcher gerade in IntelliJ geschrieben
wurde, nicht mehr und nicht weniger.
Gehe ich allerdings im Projekt ein paar Ordner
weiter zur class-Datei und öffne diese, ist
der Code bei weitem nicht mehr so verständlich,
weil er vom Compiler übersetzt wurde.
