# Wie man Java-Programmierung für Anfänger lernt**Java-Programmierung** ist die Einstiegsdroge zur Softwareentwicklung. Es spielt keine Rolle, ob Sie als Teenager Ihr erstes Spiel entwickeln oder als Rentner nach zwei Jahrzehnten voller Neugier endlich den Code knacken. Das Ziel hier ist einfach. Ich werde Ihnen beibringen, wie Computerprogramme funktionieren, indem ich Ihnen beibringe, in Java zu programmieren. Dies ist eine **HowStuffWorks**-Anleitung für Neugierige.Bevor wir eine einzige Codezeile schreiben, legen wir die Grundregeln fest. Ich gehe davon aus, dass Sie im Moment keine Ahnung vom Programmieren haben. Wenn Sie dies bereits getan haben, überfliegen Sie die Grundlagen und springen Sie zu dem, was neu ist. Ich gehe außerdem davon aus, dass Sie grundlegende Computeraufgaben bewältigen können. Dateien bearbeiten? Kopieren? Löschen? Umbenennung? Es ist gut, dorthin zu gehen.Der Einfachheit halber konzentrieren wir uns auf Windows 95, 98, 2000, NT oder XP. Wenn Sie ein anderes Betriebssystem verwenden, gelten die Konzepte weiterhin. Sie müssen sie nur zuordnen. Die einzige andere Voraussetzung ist das Verlangen.Das Beste daran? Sie zahlen keinen Cent. Java-Tools sind im Internet kostenlos verfügbar. Ebenso das Unterrichtsmaterial. Sobald Sie damit fertig sind, können Sie tiefer eintauchen, ohne Compiler, IDEs oder Lehrbücher kaufen zu müssen. Java ist ein guter Ausgangspunkt. Lernen Sie es und das Erlernen anderer Sprachen wird trivial.Fangen wir an.### Den Wortschatz verstehenWir müssen die gleiche Sprache sprechen. Buchstäblich. Hier sind die Begriffe, die uns bei Verstand halten.**Computerprogramm**
Im Kern ist ein Computerprogramm nur eine Liste von Anweisungen. Es sagt der Maschine genau, was sie tun soll. Zahlen hinzufügen. Werte vergleichen. Treffen Sie eine Entscheidung. Es ist wie ein Rezept für einen Koch oder Noten für einen Musiker. Der Computer befolgt diese Anweisungen genau. Das Ergebnis? Nützliche Dinge. Ein Scheckbuch ausgleichen. Ein Spiel anzeigen. Ausführen eines Textverarbeitungsprogramms.**Programmiersprache**
Computer sprechen kein Englisch. Oder Java. Oder Python. Sie sprechen Maschinencode. Deshalb verwenden wir eine Programmiersprache, um unsere menschliche Absicht in etwas zu übersetzen, das die Maschine erkennen kann. Es gibt Dutzende davon. Fortran. Cobol. Basic. Pascal. C. C++. Java. Perl. Sie alle drücken die gleichen Grundkonzepte aus. Nur auf unterschiedliche Weise. Es ist, als würde man verschiedene menschliche Sprachen sprechen.**Compiler**
Das ist der magische Übersetzer. Ein Compiler nimmt Ihren für Menschen lesbaren Code (wie Java) und wandelt ihn in eine Form um, die der Computer **ausführen** kann. Sie haben das Ergebnis gesehen. Diese „.exe“-Dateien auf Ihrem Desktop? Das sind die Ausgaben von Compilern. Sie enthalten **ausführbare Dateien**. Maschinenlesbare Programme, übersetzt aus menschenlesbaren Programmen.### Die Werkzeuge besorgenUm Java-Programme zu schreiben, benötigen Sie einen Compiler. Konkret ein Java-Compiler. Der nächste Abschnitt führt Sie durch das Herunterladen und Installieren.Seien Sie vorbereitet. Dies ist kein fünfminütiger Download. Es wird mehrere Stunden dauern. Die meiste Zeit wird mit dem Herunterladen großer Dateien verbracht. Sie benötigen außerdem etwa 40 Megabyte freien Speicherplatz. Überprüfen Sie jetzt Ihr Laufwerk. Stellen Sie sicher, dass Sie Platz haben, bevor Sie beginnen.Sobald Sie den Compiler haben, beginnen wir.### Einrichten der JDK 1.4.2-UmgebungDer Aufbau einer Java-Entwicklungsumgebung erfordert die lokale Installation des Compilers und der unterstützenden Tools. Es handelt sich um einen mehrstufigen Prozess. Sie benötigen die Software. Sie benötigen die Dokumente. Sie benötigen die richtigen Pfadvariablen. Wenn Sie ein Stück verpassen, funktioniert nichts.Erstellen Sie zunächst einen eigenen Ordner in Ihrem temporären Verzeichnis. Nennen Sie es das **Download-Verzeichnis**. Halten Sie das Chaos in Schach.### Die Download-PhaseSie laden drei große Dateien herunter. Wenn Sie ein DFÜ-Modem verwenden, dauert dies Stunden. Ernsthaft. Geh und hol dir einen Snack.1. **Das SDK:** Besuchen Sie die Downloadseite für Java SE 1.4.2. Klicken Sie auf den Link für das J2SE SDK. Akzeptieren Sie die Lizenz. Wählen Sie Ihr Betriebssystem. Das ist der Heavy Lifter.
2. **Die Dokumentation:** Gehen Sie zurück zum selben Hub. Holen Sie sich den Link zur SDK 1.4.1-Dokumentation. Es ist riesig.
3. **WinZip:** Wenn Sie noch kein Komprimierungstool haben, holen Sie sich eine Testversion von der WinZip-Site. Installieren Sie die „.exe“. Sie werden es bald brauchen.### Installation des KitsFühren Sie die heruntergeladene Datei „j2sdk-1_4_1-*.exe“ aus. Es entpackt sich. Das Installationsprogramm kümmert sich um die komplizierten Schritte, den Compiler dort zu platzieren, wo er hingehört.Nun zu den Dokumenten. Verschieben Sie das Dokumentationsarchiv in dasselbe Verzeichnis, in dem Sie gerade das Entwicklungskit installiert haben. Verwenden Sie WinZip, um es zu extrahieren. Wenn Sie die Verschiebung richtig durchgeführt haben, sollten die Dateien automatisch in den richtigen Unterverzeichnissen landen.### Konfigurieren des SystempfadsHier stolpern die meisten Menschen. Sie müssen die Umgebungsvariablen anpassen. Insbesondere die Variable **PATH**.Öffnen Sie eine MS-DOS-Eingabeaufforderung. Geben Sie „PFAD“ ein. Beachten Sie, was bereits vorhanden ist. Öffnen Sie „autoexec.bat“ im Editor. Fügen Sie das neue Java-bin-Verzeichnis zur Pfadzeichenfolge hinzu. Speichern Sie die Datei. Dadurch wird Ihrem Betriebssystem mitgeteilt, wo „javac“ zu finden ist.### VerifizierungSchließen Sie das DOS-Fenster. Öffnen Sie ein neues. Das ist entscheidend. Das alte Fenster sieht die Änderungen nicht.Geben Sie „javac“ ein.Wenn Sie eine zweizeilige Fehlermeldung sehen, die die Verwendung des Compilers erklärt, haben Sie gewonnen. Die Umgebung ist lebendig.Wenn Sie „Ungültiger Befehl oder Dateiname“ erhalten, haben Sie versagt. Lesen Sie die Anweisungen noch einmal. Überprüfen Sie den Pfad erneut. Seien Sie hartnäckig. Es ist keine Schande, Ihr eigenes Setup zu debuggen, Sie müssen es jedoch beheben, bevor Sie fortfahren.### Ausführen der DemosIm Installationsordner befindet sich ein Verzeichnis **demo**. Es enthält fertige Beispiele. Viele von ihnen geben Audio aus. Schalten Sie Ihre Lautsprecher ein.Suchen Sie nach Dateien mit dem Namen „example1.html“. Laden Sie sie in Ihren Webbrowser. Beobachten Sie, wie der Code in Echtzeit ausgeführt wird. Dies ist eine gute Möglichkeit, zu sehen, was der Compiler tatsächlich produziert, ohne selbst eine einzige Codezeile schreiben zu müssen.Sie haben jetzt eine Maschine, die Java kompiliert. Sie sind bereit, Software zu schreiben.### Die Leinwand aufbauen und die Linie zeichnenIhr anfänglicher Code muss prägnant sein. Das Ziel ist einfach: Erstellen Sie einen Zeichenraum und rendern Sie einen diagonalen Schrägstrich darüber. Für den Einstieg benötigen Sie keine komplexen Frameworks oder umfangreichen IDEs. Sie benötigen lediglich einen Texteditor, einen Compiler und ein grundlegendes Verständnis dafür, wie diese Teile zusammenhängen.Der Arbeitsablauf ist linear. Sie schreiben den Code. Sie speichern es mit der richtigen Erweiterung. Sie kompilieren es in Bytecode. Sie beheben die unvermeidlichen Tippfehler. Sie verpacken es in einen HTML-Container. Zum Schluss führen Sie es aus.Hier ist der Code, mit dem wir arbeiten:„Java
import java.awt.Graphics;
öffentliche Klasse FirstApplet erweitert java.applet.Applet {
Farbe für öffentliche Hohlräume (Grafiken g) {
g.drawLine(0, 0, 200, 200);
}
}
„Beachten Sie die Struktur. Es importiert die Grafikbibliothek. Es definiert eine Klasse „FirstApplet“, die von der Standardklasse „Applet“ erbt. Es überschreibt die Methode „paint“, um eine Linie von der Koordinate (0,0) bis (200,200) zu zeichnen. Das ist es.### Schritt 1: Geben Sie den Quellcode einStarten Sie ein neues Verzeichnis. Dadurch bleibt Ihr Arbeitsbereich sauber und spätere Pfadkonflikte werden vermieden. Öffnen Sie Notepad oder den von Ihnen bevorzugten Nur-Text-Editor. Geben Sie den Code genau wie oben gezeigt ein.Überspringen Sie diesen Schritt nicht. Kopieren Sie nicht und fügen Sie sie nicht ein, wenn Sie versuchen, die Syntax zu lernen. Geben Sie es ein.**Groß-/Kleinschreibung ist nicht verhandelbar.** Java unterscheidet zwischen „FirstApplet“ und „firstapplet“. Wenn Sie die Großschreibung falsch machen, wird sie vom Compiler abgelehnt. Es spielt keine Rolle, ob Ihre Logik vernünftig ist; Wenn die Groß-/Kleinschreibung falsch ist, ist die Datei ungültig. Überprüfen Sie Ihre Quelle sorgfältig.### Schritt 2: Präzise sparenSpeichern Sie die Datei als **FirstApplet.java** in diesem Verzeichnis.Überprüfen Sie den Fall noch einmal. „F“ und „A“ müssen in Großbuchstaben geschrieben werden. Alles andere in Kleinbuchstaben. Wenn Sie es als „firstapplet.java“ speichern, sucht der Compiler nach einer Klasse mit dem Namen „FirstApplet“, kann sie jedoch nicht finden und gibt einen Fehler aus.Eine häufige Falle für Windows-Benutzer: Notepad hängt standardmäßig häufig „.txt“ an Dateinamen an. Wenn Sie es als „FirstApplet.java“ speichern, erhalten Sie möglicherweise tatsächlich „FirstApplet.java.txt“. Der Compiler sieht eine „.txt“-Datei und ignoriert sie.Um Ihren Dateinamen zu überprüfen, öffnen Sie eine Eingabeaufforderung („MS-DOS-Fenster“) in diesem Verzeichnis und geben Sie „dir“ ein. Suchen Sie nach der Datei. Wenn Sie „.txt“ sehen, müssen Sie es umbenennen. Öffnen Sie alternativ den Windows Explorer, gehen Sie zum Menü „Ansicht“ und deaktivieren Sie „Erweiterungen für bekannte Dateitypen ausblenden“. Jetzt können Sie die wahre Erweiterung sehen und sie bei Bedarf umbenennen.### Schritt 3: Kompilieren des BytecodesHier geschieht die Magie. Navigieren Sie in Ihrer Eingabeaufforderung mit dem Befehl „cd“ zu Ihrem Projektverzeichnis.Führen Sie diesen Befehl aus:„Bash
javac FirstApplet.java
„Beachten Sie, dass der Befehl „javac“ (Java Compiler) und nicht „java“ lautet.Wenn es funktioniert, werden Sie nichts sehen. Keine Ausgabe. Keine Erfolgsmeldung. Nur eine neue Eingabeaufforderung. Dieses Schweigen bedeutet Erfolg. Eine Datei mit dem Namen „FirstApplet.class“ sollte jetzt in Ihrem Ordner vorhanden sein. Diese „.class“-Datei ist der Bytecode, den Ihre Java Virtual Machine (JVM) ausführt.Wenn Sie Fehler sehen, lesen Sie diese. Sie sagen Ihnen genau, was schief gelaufen ist. Normalerweise handelt es sich um ein fehlendes Semikolon, einen Tippfehler in einem Schlüsselwort oder eine nicht übereinstimmende Groß-/Kleinschreibung.Wenn „javac“ nicht als Befehl erkannt wird, ist Ihr Java-Installationspfad in Ihren Umgebungsvariablen nicht richtig eingestellt. Sie müssen das beheben, bevor Sie fortfahren.### Schritt 4: Debuggen der FehlerWenn die Kompilierung fehlschlägt, raten Sie nicht. Vergleichen Sie Ihren Code Zeile für Zeile mit der zuvor bereitgestellten Quelle. Prüfen Sie auf:* Fehlende Semikolons am Ende von Anweisungen.
* Nicht übereinstimmende geschweifte Klammern „{}“.
* Falsche Groß- und Kleinschreibung in Klassen- oder Methodennamen.Nach jedem Fix neu kompilieren. Iteration ist schneller als Perfektion. Sobald die Eingabeaufforderung ohne Fehlermeldungen zurückkehrt, haben Sie Ihr erstes Java-Applet kompiliert.### Schritt 5: Erstellen des HTML-HostsJava-Applets laufen nicht im luftleeren Raum. Sie erfordern das Laden eines HTML-Containers in einen Browser oder Viewer.Öffnen Sie ein neues Notepad-Fenster. Erstellen Sie eine einfache HTML-Struktur:“`html
„Speichern Sie diese Datei als **applet.htm** im selben Verzeichnis wie Ihre „.java“- und „.class“-Dateien.Das Tag „“ ist die Brücke. Das Attribut „code“ verweist auf die kompilierte „.class“-Datei. Die Attribute „width“ und „height“ definieren die Leinwandgröße in Pixeln. Wenn Sie diese Zahlen ändern, ändert sich der Zeichenbereich, aber die Linienkoordinaten bleiben relativ zur oberen linken Ecke (0,0).### Schritt 6: Ausführen des AppletsUm dies zu testen, benötigen Sie nicht unbedingt einen Webserver. Sie können das im Java Development Kit (JDK) enthaltene Tool „appletviewer“ verwenden.Geben Sie in Ihrer Eingabeaufforderung Folgendes ein:„Bash
Appletviewer applet.htm
„Es öffnet sich ein Fenster. Sie sollten ein weißes Kästchen mit einer diagonalen Linie sehen, die von der oberen linken Ecke zur unteren rechten Ecke verläuft.Ändern Sie die Größe des Fensters. Die Leine bleibt an den Ecken verankert.Sie können „applet.htm“ auch direkt in einen Browser wie Netscape Navigator oder Internet Explorer (historisch) laden# So zeichnen Sie Ihre erste Form in einem Java-AppletSie haben Code. Sie haben einen Browser. Du hast eine Linie.Es klingt einfach, aber dieser diagonale Streifen von Ecke zu Ecke ist der Sinn dieser Übung. Alles andere in diesen zehn Codezeilen ist nur ein Gerüst. Es hält die Struktur aufrecht, sodass die eigentliche Arbeit ausgeführt werden kann. Diese Arbeit wird durch einen einzigen Befehl definiert:`g.drawLine(0, 0, 200, 200);`Hier geschieht die Magie. Sie weisen den Computer an, eine Linie von der oberen linken Ecke (0,0) nach unten rechts (200.200) zu zeichnen. Der Computer gehorcht. Es zeichnet die Linie genau nach Anweisung. Das ist die Essenz der Programmierung.### Koordinaten und Pixel verstehenUm dies richtig zu machen, müssen Sie das Koordinatensystem verstehen. Stellen Sie sich vor, das Applet-Fenster wäre ein Raster. Die obere linke Ecke ist der Ursprung (0,0). Die X-Achse verläuft nach rechts. Die Y-Achse verläuft nach unten.Jedes Inkrement in diesem Raster ist ein Pixel.Im Code „g.drawLine(0, 0, 200, 200)“:
* `g` ist das Objekt. Konkret handelt es sich um eine Instanz der **Graphics**-Klasse.
* „drawLine“ ist eine **Methode** (oder Funktion). Es ist ein Befehl.
* Die vier Zahlen sind **Parameter**. Sie sagen der Methode, wo sie beginnen und wo sie enden soll.
* Das Semikolon am Ende wirkt wie ein Punkt in einem Satz. Ohne sie bricht der Code.Sie können diese Zahlen anpassen. Ändere sie. Speichern Sie die Datei. Mit „javac“ neu kompilieren. Im „Appletviewer“ erneut ausführen. Sehen Sie, was passiert, wenn Sie die Werte austauschen. Dies ist der schnellste Weg, um zu lernen, wie die Leinwand funktioniert.### Erkundung der Grafikklasse„drawLine“ ist nur ein Werkzeug. Was können Sie sonst noch tun?Die Antwort finden Sie in der Dokumentation. Bei der Installation des Java Development Kit (JDK) wurde eine Datei namens „java.awt.Graphics.html“ entpackt. Auf meinem System befindet es sich unter „D:\jdk1.1.7\docs\api\java.awt.Graphics.html“. Ihr Gerät befindet sich an einer ähnlichen Stelle, je nachdem, wo Sie die Werkzeuge ausgepackt haben.Öffnen Sie diese Datei. Suchen Sie nach dem „Methodenindex“. Es listet jeden Befehl auf, den die **Graphics**-Klasse unterstützt. Sie sind nicht auf gerade Linien beschränkt. Sie können Folgendes erstellen:- Bögen
– Ovale
– Polygone
– Rechtecke
– Strings (Text)
– CharaktereVersuchen Sie, sie zu kombinieren. Fügen Sie dies Ihrem Code hinzu:„Java
g.drawLine(0, 0, 200, 200);
g.drawRect(0, 0, 200, 200);
g.drawLine(200, 0, 0, 200);
„Dadurch wird ein quadratisches Kästchen mit einem X darüber gezeichnet. Stellen Sie sicher, dass Ihr Applet-Fenster groß genug ist, um die gesamte Form anzuzeigen. Andernfalls werden nur Fragmente angezeigt.### Farben ändernOhne Farbe sind Formen langweilig. Die **Graphics**-Klasse verarbeitet Farben nicht direkt. Sie benötigen die Klasse **Color**. Aus diesem Grund fügen wir oben in der Datei eine Importanweisung ein.So füllen Sie ein Feld mit Rot und zeichnen darüber schwarze Linien:„Java
import java.awt.Graphics;
java.awt.Color importieren;öffentliche Klasse FirstApplet erweitert java.applet.Applet {
Farbe für öffentliche Hohlräume (Grafiken g) {
g.setColor(Color.red);
g.fillRect(0, 0, 200, 200);
g.setColor(Color.black);
g.drawLine(0, 0, 200, 200);
g.drawLine(200, 0, 0, 200);
}
}
„Beachten Sie den neuen Import in Zeile 2. Er zieht die Klasse „Color“ ein, sodass der Computer weiß, was „Rot“ und „Schwarz“ als tatsächliche Farben und nicht nur als Zeichenfolgen bedeuten.Das Ergebnis ist ein rotes Quadrat mit einem schwarzen Kreuz darin. Sie haben den Status des Grafikkontexts mit „setColor“ geändert. Dann haben Sie den Zeichenbefehl ausgeführt. Dann haben Sie die Farbe erneut geändert. Dann hast du wieder gezeichnet.Es handelt sich um eine Folge von Befehlen. Nacheinander. Der Bildschirm spiegelt den Endstatus dieser Befehle wider.Experimentieren Sie mit anderen Formen. Versuchen Sie es mit „drawOval“. Versuchen Sie es mit „drawArc“. Ändern Sie die Farben in Blau. Oder grün. Oder lila. Die Dokumentation listet sie alle auf. Der Code ist einfach, wenn Sie aufhören, auf das Gerüst zu schauen, und sich auf die Befehle konzentrieren.Was passiert, wenn Sie das Rechteck größer als das Fenster machen? Was passiert, wenn Sie die X- und Y-Koordinaten vertauschen? Der Browser schneidet den Überschuss ab. Die Mathematik läuft immer noch. Der Bildschirm zeigt einfach, was passt.Das war’s mit den Grundlagen. Der Rest besteht nur aus mehr Formen.# Java-Grafiken verstehen: Sequentielle Logik und Debugging-GrundlagenDie Syntax fühlt sich zunächst oft wie Magie an. Sie sehen **Color.red** und fragen sich, warum es nicht einfach „rot“ ist. Sie sehen diese zusätzliche Importzeile und fragen, woher der Compiler weiß, wo sie zu finden ist. Das kann man sich nicht aus einem Regelwerk merken. Sie lernen es, indem Sie sehen, wie es verwendet wird.Da ich Ihnen gezeigt habe, wie man **setColor** aufruft, kennen Sie jetzt das Muster. Verwenden Sie **Color.** gefolgt vom Namen. Fügen Sie den Import hinzu. Das ist der Kern der Programmierung. Es geht nicht darum, alle Fakten zu kennen. Es geht darum, Muster zu erkennen. Lesen Sie ein Beispiel. Überprüfen Sie die Dokumente. Schauen Sie sich den Democode an. Bewahren Sie die Technik auf. Dann verwenden Sie es im nächsten Programm. Wenn Ihnen der Kreislauf des Lernens und Erinnerns Spaß macht, wird Ihnen dieser Job gefallen.### Die Bedeutung der CodereihenfolgeWir schreiben immer noch linearen Code. Das bedeutet, dass der Computer von oben nach unten liest. Es springt nicht herum. Es führt Methodenaufrufe in der genauen Reihenfolge aus, in der sie erscheinen.Ordnung ist wichtig.Versuchen Sie, eine Linie zu zeichnen. Zeichnen Sie dann ein rotes Rechteck über denselben Bereich. Die Zeile ist immer noch im Gedächtnis vorhanden. Aber es ist unsichtbar. Das Rechteck deckt es ab. Wenn Sie die Reihenfolge umkehren, wird das Rechteck zuerst angezeigt, dann erscheint die Linie oben.Diese sequentielle Struktur ist das Rückgrat jedes Programms. Experimentieren Sie mit den Zeichenmethoden. Zerbrich sie. Sehen Sie, was klebt.## Bugs und Debugging: Ein normaler Teil des LebensDu wirst Fehler machen. Jeder tut es. Der Compiler wird Sie anschreien, oder das Programm wird ausgeführt, sieht aber falsch aus.Diese Probleme werden **Bugs** genannt. Der Prozess zur Behebung dieser Probleme ist **Debuggen**.Programmierer verbringen etwa die Hälfte ihrer Zeit mit dem Debuggen. Es ist kein Zeichen des Scheiterns. Es ist nur ein Teil der Arbeit.### Compilerfehler vs. AusführungsfehlerEs gibt zwei Haupttypen von Problemen, mit denen Sie konfrontiert sein werden.1. **Compilerfehler**: Der Code wird überhaupt nicht ausgeführt.
2. **Ausführungsfehler**: Der Code wird ausgeführt, aber die Ausgabe ist falsch.Sie können das gezielte Auffinden von Compilerfehlern üben. Löschen Sie ein Semikolon. Schreiben Sie einen Funktionsnamen falsch. Entfernen Sie einen Import. Mit **javac** kompilieren.Die Fehlermeldung könnte zunächst beängstigend aussehen. Es ist nur Text. Es sagt Ihnen, was schief gelaufen ist. Indem Sie diese Fehler selbst erstellen, erfahren Sie, wonach der Compiler sucht. Sie geraten nicht mehr in Panik, wenn sie im echten Code auftauchen. Sie wissen genau, was Sie reparieren müssen.Ausführungsfehler sind schwieriger. Das Programm wird kompiliert. Es startet. Aber es macht nicht das, was Sie erwartet haben.Betrachten Sie diesen Codeausschnitt:„Java
g.setColor(Color.red);
g.fillRect(0, 0, 200, 200);
g.setColor(Color.black);
g.drawLine(0, 0, 200, 200);
g.drawLine(200, 0, 0, 200);
„Dadurch wird ein rotes Rechteck gezeichnet. Dann zeichnet es zwei schwarze diagonale Linien darüber. Die Linien sind sichtbar.Schauen Sie sich nun diese Version an:„Java
g.setColor(Color.black);
g.drawLine(0, 0, 200, 200);
g.drawLine(200, 0, 0, 200);
g.setColor(Color.red);
g.fillRect(0, 0, 200, 200);
„Der Code ist nahezu identisch. Die gleichen Methoden. Gleiche Parameter. Aber das Ergebnis ist völlig anders.Das Rechteck wird *nach* den Linien gezeichnet. Es verdeckt sie vollständig. Wenn Sie die Diagonalen sehen möchten, enthält dieser zweite Block einen Fehler. Es handelt sich um einen logischen Fehler. Der Computer hat genau das getan, was Sie ihm gesagt haben. Du hast einfach das Falsche gesagt.### Subtile LogikfehlerHier ist ein weiteres Beispiel, das schwerer zu erkennen ist.„Java
g.drawLine(0, 0, 200, 200);
g.drawRect(0, 0, 200, 200);
g.drawLine(200, 0, 0, 200);
„Dadurch entsteht eine schwarze Box mit zwei sich kreuzenden diagonalen Linien im Inneren.Ändern Sie nun eine Codezeile:„Java
g.drawLine(0, 0, 200, 200);
g.drawRect(0, 0, 200, 200);
g.drawLine(0, 200, 0, 200);
„Schauen Sie sich die letzte Zeile genau an.Der vorherige Code hat eine Linie von rechts oben nach links unten gezeichnet. Dieser Code versucht, eine Linie von unten links nach … unten links zu zeichnen. Die Start- und Endpunkte sind gleich. Es zeichnet nichts Sichtbares.Sie erwarten zwei Diagonalen. Du siehst einen. Der Fehler ist subtil. Es dauerte eine Sekunde, bis ich es bemerkte. Das sind die Fehler, die Stunden verschwenden. Sie sind leicht zu übersehen, da der Code korrekt aussieht. Sie müssen sich die Logik ansehen, nicht nur die Syntax.### Umfassen Sie die FrustrationSie werden Ihre eigenen Fehler früh genug finden. Sie werden dich nerven. Das ist normal.Der durchschnittliche Programmierer verbringt die Hälfte seiner Zeit damit, diese aufzuspüren. Lass es dich nicht kaputt machen. Du versagst nicht. Sie tun, was Programmierer tun. Sie schreiben Code. Du findest den Fehler. Du behebst es. Wiederholen.Es wird einfacher. Die Muster beginnen einen Sinn zu ergeben. Die Fehlermeldungen werden zu freundlichen Wegweisern statt zu kryptischen Beleidigungen.Aber machen Sie vorerst weiterhin Dinge kaputt. Brechen Sie sie absichtlich. Sehen Sie, wie sie scheitern. So lernt man, sie wieder zusammenzusetzen.Das Rechteck wird nach den Linien gezeichnet. Es verdeckt sie. Die Reihenfolge ist alles.Was passiert, wenn Sie eine dritte Form hinzufügen? Hält die Logik? Oder verwandelt sich der Bildschirm in ein Durcheinander überlappender Pixel?Du wirst es früh genug erfahren.# Warum Java-Variablen wichtig sind und wie man sie richtig verwendetJede Software, die Sie berühren, ist auf **Variablen** angewiesen, um Daten vorübergehend zu speichern. Es klingt einfach, ist aber das Rückgrat der Logik. Wenn ein Programm eine Eingabe anfordert, verschwindet diese Eingabe nicht einfach. Es wird in einer Variablen gespeichert, damit der Code später darauf verweisen kann. Sie können diesen Schritt nicht überspringen.Java zwingt Sie dazu, dies explizit zu sagen. Sie müssen eine Variable **definieren** oder **deklarieren**, bevor Sie sie verwenden können. Sie müssen ihm auch einen bestimmten **Typ** zuweisen. Eine Variable könnte eine ganze Zahl enthalten. Ein anderer könnte eine Textzeichenfolge enthalten. Diese Strenge ist der Grund, warum Java eine **stark typisierte** Sprache ist. In anderen Sprachen kommen Sie vielleicht mit lockerem Tippen davon, aber starkes Tippen reduziert Fehler in großen Projekten. Es erkennt Fehler, bevor sie zu Produktionsfehlern werden.Schauen Sie sich diesen Ausschnitt an:„Java
import java.awt.Graphics;
java.awt.Color importieren;öffentliche Klasse FirstApplet erweitert java.applet.Applet {
Farbe für öffentliche Hohlräume (Grafiken g) {
int width = 200;
int Höhe = 200;
g.drawRect(0, 0, Breite, Höhe);
g.drawLine(0, 0, width, height);
g.drawLine(width, 0, 0, height);
}
}
„Hier werden **Breite** und **Höhe** deklariert. Ihr Typ ist **int**. Ein **int** enthält ganze Zahlen – ganze Zahlen wie 1, 2 oder 3. Wir haben sie auch auf 200 **initialisiert**. Initialisierung bedeutet, die Variable auf ihren ersten Wert zu setzen. Sie könnten es in zwei Schritten aufschreiben:„Java
int Breite;
Breite = 200;
„Das kombinierte Formular ist einfach schneller zu tippen. Aber überspringen Sie nicht die Initialisierung. Das Vergessen, eine Variable auf ihren ersten Wert zu setzen, ist ein häufiger Fehler. Wenn Sie „= 200“ entfernen und versuchen zu kompilieren, gibt der Compiler einen Fehler aus. Das ist keine Einschränkung. Es ist ein Sicherheitsnetz. Dies erspart Ihnen das spätere Debuggen undefinierten Verhaltens.Java verarbeitet Daten auf zwei Arten: einfache **primitive** Variablen und **Klassen**.**int** ist primitiv. Es enthält eines: eine Zahl. Es kann nicht viel anderes tun. **Klassen** sind unterschiedlich. Sie bündeln mehrere Teile und umfassen Methoden zur Manipulation dieser Daten. Die Klasse **Rectangle** ist ein perfektes Beispiel.### Code mit Klassenvariablen dynamisch machenDas vorherige Beispiel war starr. Es wurde davon ausgegangen, dass das Fenster genau 200 x 200 Pixel groß war. Was passiert, wenn sich die Fenstergröße ändert? Was ist, wenn Sie möchten, dass sich die Zeichnungslogik automatisch anpasst?Sie müssen die Grafikumgebung fragen, wie groß sie tatsächlich ist. Die **Graphics**-Klasse (zu finden in „java.awt.Graphics“) verfügt über eine Methode namens **getClipBounds**. Es werden keine Parameter benötigt. Es **gibt** ein **Rectangle**-Objekt zurück. Dieses Objekt enthält die Breite und Höhe des verfügbaren Zeichenbereichs.In diesem **Rectangle**-Objekt befinden sich vier Variablen: **x**, **y**, **width** und **height**. Der Zugriff erfolgt über die Punktnotation.So schreiben Sie den Code so um, dass er dynamisch ist:„Java
import java.awt.Graphics;
java.awt.Color importieren;
import java.awt.Rectangle;öffentliche Klasse FirstApplet erweitert java.applet.Applet {
Farbe für öffentliche Hohlräume (Grafiken g) {
int Breite;
int Höhe;
Rechteck r;r = g.getClipBounds();
width = r.width – 1;
height = r.height – 1;g.drawRect(0, 0, Breite, Höhe);
g.drawLine(0, 0, width, height);
g.drawLine(width, 0, 0, height);
}
}
„Hier entstehen drei neue Konzepte.Zuerst müssen Sie **java.awt.Rectangle** importieren. Andernfalls erkennt der Compiler den Typ nicht.Zweitens haben wir drei Variablen deklariert. **width** und **height** sind **int**-Typen. **r** ist ein **Rechteck**-Objekt.Drittens haben wir „g.getClipBounds()“ aufgerufen. Das Ergebnis wird **r** zugewiesen. Die Klasse **Rectangle** speichert Daten intern. Um die Breite zu erhalten, fragen Sie nicht einfach nach der **Breite**. Sie fragen nach „r.width“. Der Punktoperator weist Java an, im Objekt **r** nach der Eigenschaft namens **width** zu suchen.Wir haben von beiden Werten 1 abgezogen. Warum? Denn Zeichnungskoordinaten verhalten sich je nach Implementierungsdetails des Grafiksystems oft unterschiedlich. Wenn Sie „- 1“ entfernen, wird das Rechteck möglicherweise um ein oder zwei Pixel abgeschnitten. Wenn Sie 5 subtrahieren, sehen Sie eine deutliche Lücke. Das Experimentieren mit diesen Zahlen hilft Ihnen, das Koordinatensystem zu verstehen.Schließlich haben wir diese dynamischen Werte für **Breite** und **Höhe** an die Zeichenfunktionen übergeben. Wenn Sie nun die Größe des Browserfensters ändern, werden das Rechteck und die Diagonalen automatisch neu angepasst. Der Code passt sich an.Einige Entwickler fragen, ob hier die Erstellung lokaler Variablen wie **width** und **height** notwendig ist. Technisch gesehen nein. Sie könnten „g.drawRect(0, 0, r.width – 1, r.height – 1)“ schreiben. Aber diese Schlange wird lang. Es wird schwer zu lesen. Durch die Verwendung von Zwischenvariablen wird der Code sauberer. Es ist eine kleine Angewohnheit, die sich in der Wartbarkeit auszahlt.Java unterstützt mehrere primitive Typen. **int** wird am häufigsten für ganze Zahlen verwendet. Andere beinhalten **double** für Dezimalzahlen und **boolean** für Wahr/Falsch-Zustände. Jeder hat seinen Platz. Wenn Sie wissen, wann Sie es verwenden müssen, bleibt Ihre Logik straff und Ihre Fehlerquote gering.# Java-Primitive: Umgang mit Mathematik mit float und charWenn man die komplexen Objekte und Schnittstellen entfernt, reduziert sich Java auf das Wesentliche. Sie haben Ihre Kernbausteine. Insbesondere „float“ für Dezimalzahlen wie 3,14159 und „char“ für einzelne Zeichen wie „a“ oder „z“. Das sind nicht nur Etiketten. Sie sind das Rohmaterial für die Berechnung.Java weiß, wie man diese Typen mit Standardarithmetik jongliert. Sie können das Pluszeichen ***+** für die Addition, das Minuszeichen **-** für die Subtraktion, das Sternchen ***** für die Multiplikation und den Schrägstrich **/** für die Division verwenden. Es gibt noch mehr Operatoren, aber diese vier decken den Großteil der einführenden Logik ab.Schauen wir uns ein konkretes Beispiel an. Angenommen, Sie müssen das Volumen einer Kugel berechnen. Die Kugel hat einen Durchmesser von 10 Fuß. Man kann die Lautstärke nicht einfach erraten. Man muss es aus dem Radius ableiten. So würden Sie diese Logik in Java schreiben:„Java
Schwimmerdurchmesser = 10;
Schwimmradius;
Float-Volumen;
Radius = Durchmesser / 2,0;
Volumen = 4,0 / 3,0 * 3,14159 * Radius * Radius * Radius;
„Es sieht aus wie eine Zahlenfolge, aber jede Zeile leistet eine bestimmte Aufgabe. Die erste Berechnung weist die Maschine an, den in der Variablen „Durchmesser“ gespeicherten Wert zu nehmen, ihn durch 2,0 zu dividieren und das Ergebnis in die Variable „Radius“ zu übertragen. Einfache Aufteilung.Der Zuweisungsoperator „=“ erledigt hier die schwere Arbeit. Es bedeutet nicht „gleich“ im mathematischen Sinne der Symmetrie. Es bedeutet „Nimm das Ergebnis von der rechten Seite und füge es in die Variable auf der linken Seite ein.“Warum ist das für einen Entwickler wichtig? Denn das Verständnis der Zuweisungsrichtung ist der Unterschied zwischen Code, der funktioniert, und Code, der stillschweigend fehlschlägt. Der Wert fließt von rechts nach links. Die Variable auf der linken Seite ist der Bucket. Die Berechnung rechts ist das Wasser. Wenn Sie sie umdrehen, erhalten Sie einen Syntaxfehler oder, schlimmer noch, einen logischen Fehler, der schwer zu erkennen ist.Sie können diese Vorgänge verketten. Multiplizieren. Teilen. Speichern. Abrufen. Der Typ „float“ verarbeitet die Dezimalzahlen und ermöglicht eine Präzision, bei der ganze Zahlen den Rest abschneiden würden. Es ist nicht so genau wie die doppelte Genauigkeit, aber für viele alltägliche Berechnungen reicht es aus. Und es ist schnell.Der Typ „char“ befindet sich in der Nähe und wartet auf eine Einzelbyte-Eingabe. Es macht Mathematik nicht auf die gleiche Weise. Sie können es zu einer Ganzzahl hinzufügen und es wird deren ASCII-Wert verwenden, aber das ist normalerweise eine einfache Sache. Bleiben Sie dabei, es für Text zu verwenden. Verwenden Sie „float“ für die Zahlen. Den Rest erledigt der Compiler.Das ist der Maschinenraum. Kein Schnickschnack. Nur Daten, die von einem Container in einen anderen verschoben und durch einfache Regeln transformiert werden. Daraus kann man Welten bauen. Oder Sie berechnen einfach das Volumen einer Kugel. Beides ist gültig. Der Maschine ist es egal, was Sie wählen. Es ist nur wichtig, dass Sie ihm genau sagen, wo das Ergebnis abgelegt werden soll.# Wie Java-Schleifen funktionieren: while vs. for-Anweisungen und Vermeidung von EndlosschleifenComputer sind für die Wiederholung gebaut. Menschen langweilen sich, wenn sie zum dritten Mal aufgefordert werden, dasselbe zu tun. Computer tun das nicht. Hier kommt **Looping** ins Spiel. Dabei handelt es sich um den Mechanismus, der einen sequentiellen Codeblock immer wieder laufen lässt, bis sich eine Bedingung ändert.Ohne Schleifen wäre das Programmieren eine Übung im Kopieren und Einfügen. Ziehen Sie in Erwägung, ein Raster zu zeichnen.### Die mühsame Alternative: Sequentielle CodeStellen Sie sich vor, Sie müssten horizontale Linien für ein Raster zeichnen. Sie könnten jeden einzelnen Zeilenbefehl ausschreiben.„Java
import java.awt.Graphics;
öffentliche Klasse FirstApplet erweitert java.applet.Applet {
Farbe für öffentliche Hohlräume (Grafiken g) {
int y;
y = 10;
g.drawLine(10, y, 210, y);
y = y + 25;
g.drawLine(10, y, 210, y);
y = y + 25;
g.drawLine(10, y, 210, y);
// … stellen Sie sich vor, das würde Hunderte von Zeilen dauern …
y = y + 25;
g.drawLine(10, y, 210, y);
}
}
„Das funktioniert. Es zeichnet neun horizontale Linien mit einer Länge von jeweils 200 Pixeln. Aber schauen Sie sich den Code an. Es ist repetitiv. Es ist hässlich. Und wenn Sie ein Raster mit Tausenden von Zeilen benötigen würden, würden Sie tippen, bis Ihnen die Finger bluten.Es gibt hier eine seltsame Syntax, die Anfänger aus der Fassung bringt. `y = y + 25;`. Es sieht aus wie ein Rechenfehler. Wie kann „y“ sich selbst plus 25 ergeben?Es bedeutet nicht Gleichheit im mathematischen Sinne. Es bedeutet Auftrag. Nehmen Sie den aktuellen Wert in „y“ ein. Fügen Sie 25 hinzu. Setzen Sie das neue Ergebnis wieder in „y“. Wenn „y“ bei 10 beginnt, wird es 35. Wenn es 35 ist, wird es 60. Es ist ein Zähler, der sich vorwärts bewegt.### Die Lösung: Die while-SchleifeSie müssen nicht zehnmal dieselben zwei Zeilen eingeben. Sie benötigen eine **Schleife**. Konkret handelt es sich um eine „while“-Schleife.„Java
import java.awt.Graphics;
öffentliche Klasse FirstApplet erweitert java.applet.Applet {
Farbe für öffentliche Hohlräume (Grafiken g) {
int y;
y = 10;
while (y <= 210) {
g.drawLine(10, y, 210, y);
y = y + 25;
}
}
}
„Dieser Code macht genau das Gleiche. Es zeichnet die neun Linien. Aber der Code ist sauberer. Es ist skalierbar.### Wie die while-Anweisung tatsächlich funktioniertDas Schlüsselwort „while“ ist eine Kontrollstruktur. Es weist Java an, eine Bedingung zu prüfen, bevor der Code in den geschweiften Klammern „{ }“ ausgeführt wird.1. **Überprüfen**: Java prüft den Ausdruck in Klammern. Ist „y“ kleiner oder gleich 210?
2. **Ja**: Java betritt den Block. Es zieht eine Linie. Es aktualisiert „y“ (fügt 25 hinzu). Dann trifft es auf die schließende Klammer „}“. Es springt zurück nach oben und stellt die Frage erneut.
3. **Nein**: Die Bedingung ist falsch. Java überspringt den Block vollständig. Es geht zur nächsten Codezeile über.Lassen Sie uns die ersten Schritte verfolgen:
- „y“ beginnt bei 10. 10 <= 210. Stimmt.
- Zeichnen Sie eine Linie bei y=10.
- „y“ wird zu 35.
- Schleife zurück. 35 <= 210. Stimmt.
- Zeichnen Sie eine Linie bei y=35.
- „y“ wird zu 60.Dies wird wiederholt, bis „y“ 210 überschreitet. Dann stoppt die Schleife.### Aufbau des vollständigen RastersUm das Raster fertigzustellen, benötigen Sie auch vertikale Linien. Sie könnten eine zweite, separate „while“-Schleife schreiben.„Java
import java.awt.Graphics;
öffentliche Klasse FirstApplet erweitert java.applet.Applet {
Farbe für öffentliche Hohlräume (Grafiken g) {
int x, y;// Horizontale Linien
y = 10;
while (y <= 210) {
g.drawLine(10, y, 210, y);
y = y + 25;
}// Vertikale Linien
x = 10;
while (x <= 210) {
g.drawLine(x, 10, x, 210);
x = x + 25;
}
}
}
„### Anatomie einer While-SchleifeEine „while“-Schleife basiert auf drei verschiedenen Teilen, auch wenn diese nicht alle in einer Zeile stehen:1. **Initialisierung**: Festlegen der Variablen (z. B. „y = 10“), bevor die Schleife beginnt.
2. **Bewertung**: Die Bedingung in den Klammern (z. B. „y <= 210“).
3. **Inkrementieren/Aktualisieren**: Ändern der Variablen, sodass die Schleife schließlich endet (z. B. „y = y + 25“).Wenn eines davon fehlt oder defekt ist, schlägt die Schleife fehl.### Die for-Schleife: Eine AbkürzungJava bietet eine kompaktere Möglichkeit, dieses allgemeine Muster zu schreiben. Die „for“-Schleife.Wenn Sie eine „while“-Schleife mit Initialisierung, Bedingung und Aktualisierung haben, können Sie diese in einer Zeile zusammenfassen.**Während Version:**
„Java
y = 10;
while (y <= 210) {
g.drawLine(10, y, 210, y);
y = y + 25;
}
„**Für Version:**
„Java
für (y = 10; y <= 210; y = y + 25) {
g.drawLine(10, y, 210, y);
}
„Die „for“-Schleife fügt keine neue Funktionalität hinzu. Es packt lediglich die Initialisierung, Bedingung und Aktualisierung in eine einzige Kopfzeile. Es spart Platz. Es reduziert visuelle Unordnung. Einige Entwickler bevorzugen es für einfache Zähler. Andere finden es schwieriger zu lesen, wenn die Logik komplex wird. Es ist eine reine Stilwahl.### Zwei kritische Punkte zu Schleifen#### Richtung spielt keine Rolle
Sie müssen nicht hochzählen. Sie können herunterzählen.Initialisieren Sie „y“ auf 210. Überprüfen Sie, ob „y >= 10“ ist. Subtrahieren Sie jedes Mal 25. Das Ergebnis ist identisch. Den meisten Menschen fällt das Addieren im Kopf leichter als das Subtrahieren, aber wenn Sie die absteigende Reihenfolge bevorzugen, versuchen Sie es. Dem Computer ist es egal.#### Der Endlosschleifenfehler
Dies ist der häufigste Fehler für neue Programmierer.Was passiert, wenn Sie den Inkrementierungsschritt vergessen?„Java
y = 10;
while (y <= 210) {
g.drawLine(10, y, 210, y);
// y = y + 25; <-- Fehlt!
}
„„y“ bleibt für immer bei 10. 10 ist immer kleiner oder gleich 210. Die Bedingung ist immer wahr. Die Schleife endet nie. Das Programm hängt. Der Computer friert ein. Sie müssen das Fenster zwangsweise schließen oder die Maschine neu starten.Dies wird als **Endlosschleife** bezeichnet. Es ist ein Fehler. Es ist vermeidbar. Stellen Sie immer sicher, dass sich Ihre Schleifenvariable in Richtung der Beendigungsbedingung bewegt.### ÜbenDer beste Weg, dies zu verstehen, besteht darin, es zu schreiben. Versuchen Sie, Programme zu erstellen, die mithilfe von Schleifen bestimmte Figuren zeichnen. Fangen Sie einfach an. Zeichne ein Dreieck. Zeichne ein Sternmuster. Sehen Sie, wie sich die Koordinaten mit jeder Iteration ändern.> Beim Looping geht es nicht nur darum, Tastenanschläge zu speichern. Es geht darum, in Mustern und nicht in Reihenfolgen zu denken.### Wohin von hier aus?Wenn Sie tiefer in die Mechanik von Java eintauchen oder neugierig sind, wie es im Vergleich zu Python, C++ oder den neueren Konkurrenten im Laufzeitbereich abschneidet, geht der Ressourcenpfad weiter. Auf der nächsten Seite finden Sie eine Reihe kuratierter Links, die die Lücke zwischen grundlegender Syntax und unternehmenstauglicher Bereitstellung schließen sollen.Sie finden Dokumentation für bestimmte JDK-Versionen, Community-Foren, die sich mit häufigen Parallelitätsfehlern befassen, und Vergleiche der JVM-Leistung in verschiedenen Betriebsumgebungen. Dabei handelt es sich nicht nur um akademische Übungen. Es handelt sich um praktische Leitfäden für Entwickler, die wissen müssen, welche Bibliothek die Speicherverwaltung effizienter handhabt oder wie die Garbage Collection für Anwendungen mit hohem Durchsatz konfiguriert wird.> Der wahre Wert liegt nicht nur in der Kenntnis der Syntax, sondern auch im Verständnis des Ökosystems, das sie umgibt.Unabhängig davon, ob Sie einen Klassenpfadfehler beheben oder Java für eine neue Microservices-Architektur evaluieren, bieten diese Referenzen die konkreten Details, die Sie benötigen. Die Informationen sind so strukturiert, dass Sie über die „Anleitung“ hinaus in den Bereich „Warum es so funktioniert“ vordringen können. Klicken Sie sich durch, um auf die gesamte Materialsammlung zuzugreifen.
