1 Voraussetzungen

Dieser Artikel setzt Kenntnisse für Inno-Setup (http://www.jrsoftware.org/isinfo.php) voraus. Ich benutze für die Bearbeitung der Inno-Setup Skripte die grafische Oberfläche InnoIDE (http://www.innoide.org/), die ich auch sehr empfehlen kann. Damit ist das Durcharbeiten dieses Artikels auf jeden Fall einfacher.

2 Custom Messages

Als erstes müssen wir in das Skript drei so genannte “Custom Messages” einfügen. Das sind Textbausteine, die allein noch nichts tun. Wir müssen sie aber anlegen, damit wir sie später verwenden können, um den Benutzer zu informieren oder zu befragen:

[CustomMessages]
german.jre_not_found=Für {#MyAppName} wird Java benötigt. %nAuf diesem Computer wurde kein Java gefunden. %n%nWollen Sie es jetzt installieren?
german.jre_too_old=Für {#MyAppName} wird eine aktuelle Version von Java benötigt. %nDas auf diesem Computer installierte Java ist jedoch veraltet. %n%nWollen Sie es jetzt eine aktuelle Version von Java installieren?
german.installing_jre=Java wird installiert... Bitte warten....

3 Files

Dann muss im Abschnitt “Files” das JRE-Installationsprogramm mitgeliefert werden, dass im Falle einer veralteten oder gar nicht vorhandenen JRE auf dem PC ausgeführt wird:

[Files]
Source: jre-6u22-windows-i586-s.exe; DestDir: "{app}"; Flags: ignoreversion

4 Run

Im Abschnitt “Run” wird eingetragen, dass das zuvor hinzugefügte JRE-Installationsprogramm nach dem eigentlichen Setup ausgeführt werden soll. Dies ist allerdings mit der Bedingung “CheckJRE” verknüpft, wie man es ganz am Ende der Zeile sehen kann. Das bedeutet, dass diese Anweisung nicht immer ausgeführt wird, sondern nur wenn die Bedingung mit dem Namen “CheckJRE” erfüllt ist. Im Klartext wird hier eine Funktion weiter unten mit genau diesem Namen aufgerufen. Der Boolean(Ja/Nein)-Rückgabewert entscheidet, ob das JRE-Installationsprogramm gestartet wird, oder nicht.

[Run]
Filename: {app}\jre-6u22-windows-i586-s.exe; StatusMsg: "{cm:installing_jre}"; Check: CheckJRE;

5 Code

Hier kommen wir zur eigentlichen JRE-Prüfung, einer Funktion mit dem Namen “CheckJRE”, wie sie aus dem “Run”-Abschnitt aufgerufen wird.
Hier werden auch die Textbausteine von weiter oben verwendet.
In der Funktion gibt es eine Zeile “NecessaryJREVersion := ’1.6′;”, dort kann man die gewünschte bzw. minimale JRE-Version eintragen, die vorausgesetzt werden soll. Dies muss nicht zwingend mit der mitgelieferten JRE-Version übereinstimmen. Es kann durchaus auch eine JRE-Version 1.6 mitgeliefert werden (wie weiter oben beschrieben), es wird im Inno-Setup vielleicht aber nur JRE 1.5 vorausgesetzt.

[code]
Function CheckJRE(): Boolean;
var
  CurrentJREVersion: String;
  NecessaryJREVersion: String;
  JRENotFound: Boolean;
  JRETooOld: Boolean;
  InstallJRE: Boolean;
 
begin
 
  NecessaryJREVersion := '1.6';
  JRENotFound := False;
  JRETooOld := False;
 
  // check for JRE in registry  
  if (RegQueryStringValue(HKEY_LOCAL_MACHINE, 'SOFTWARE\JavaSoft\Java Runtime Environment', 'CurrentVersion', CurrentJREVersion)) then
  begin
    JRETooOld := (CurrentJREVersion < NecessaryJREVersion);
  end else begin
    JRENotFound := True;
  end;
 
  // ask user
  InstallJRE := False;
 
  if (JRENotFound) then
  begin
 
    if (MsgBox(ExpandConstant('{cm:jre_not_found}'), mbinformation, mb_YesNo) = idYes) then
    begin
      InstallJRE := True;
    end;
  end;
 
  if (JRETooOld) then
  begin
    if (MsgBox(ExpandConstant('{cm:jre_too_old}'), mbinformation, mb_YesNo) = idYes) then
    begin
      InstallJRE := True;
    end;
  end;
 
  Result := InstallJRE;
 
end;

6 Ende

Ich hoffe, dass ich mit diesem Artikel weiter helfen konnte und freue mich über Feedback in Form von Kommentaren und Verbesserungsvorschlägen.

Zeilenumbrüche muss man selbst setzen, und zwar mit \n im String. Wenn ich oder jemand von Euch ein Stück Code parat hat, wie man das noch elegant automatisieren könnte, werde ich den Code hier auch gerne noch veröffentlichen.

Weitere Variationen von der normalen Sprechblase, wie man sie oben sehen kann, sind durch Anpassung des Codes sehr einfach machbar:

Und hier die kommt die vereinfachte Java-Klasse, die nur den Sprech-Schnabel von links implementiert hat. Über Feedback in Form von Kommentaren und Verbesserungsvorschlägen würde ich mich sehr freuen!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

import java.awt.*;
import java.awt.geom.Path2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;
 
public class BubbleFactory {
 
    private static final int X = 10;
    private static final int Y = 10;
    private static final int BORDER_HORIZONTAL = 15;
    private static final int BORDER_VERTICAL = 10;
    private static final double CORNER_ARC_HORIZONTAL_PERCENTAGE = 0.55;
    private static final double CORNER_ARC_VERTICAL_PERCENTAGE = 0.35;
    private static final double FONT_VERTICAL_OFFSET_PERCENTAGE = 0.15;
    private static final int BUBBLE_MIN_WIDTH = 100;
 
    private static final int LIP_WIDTH = 10;
    private static final int LIP_HEIGHT = 15;
    private static final int LIP_OFFSET = 15;
 
    public static Image buildBubble(String text) {
 
        // first buffered image for calculations
        BufferedImage calcImage = new BufferedImage(10, 10, BufferedImage.TYPE_INT_ARGB);
        Graphics2D calcg2d = (Graphics2D)calcImage.getGraphics();
 
        // text and border calculations
        String[] lines = text.split("\n");
        int textHeight = calcg2d.getFontMetrics().getHeight();
        int textHeightTotal = textHeight * lines.length;
        int textWidthTotal = 0;
        for (String s : lines) {
            int lineWidth = calcg2d.getFontMetrics().stringWidth(s);
            textWidthTotal = Math.max(lineWidth, textWidthTotal);
        }
 
        int borderWidth = Math.max((2 * BORDER_HORIZONTAL) + textWidthTotal, BUBBLE_MIN_WIDTH);
        int borderHeight = (2 * BORDER_VERTICAL) + textHeightTotal;
        int arcHorizontal = (int)(borderWidth * CORNER_ARC_HORIZONTAL_PERCENTAGE);
        int arcVertical = (int)(borderWidth * CORNER_ARC_VERTICAL_PERCENTAGE);
 
        // actual buffered image
        BufferedImage resultImage = new BufferedImage(X + borderWidth + 10, Y + borderHeight + 50, BufferedImage.TYPE_INT_ARGB);
        Graphics2D g2d = (Graphics2D)resultImage.getGraphics();
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
 
        // border
        Shape roundRectangle = new RoundRectangle2D.Double(X, Y, borderWidth, borderHeight, arcHorizontal, arcVertical);
        g2d.setColor(Color.WHITE);
        g2d.fill(roundRectangle);
        g2d.setColor(Color.BLACK);
        g2d.draw(roundRectangle);
 
        // text
        int verticalOffset = (int)(textHeight * FONT_VERTICAL_OFFSET_PERCENTAGE);
        for (int i = 0; i < lines.length; i++) {
            String line = lines[i];
            int lineWidth = g2d.getFontMetrics().stringWidth(line);
            int x = X + (borderWidth / 2) - (lineWidth / 2);
            int y = Y + BORDER_VERTICAL + (textHeight * (i + 1)) - verticalOffset;
            g2d.drawString(line, x, y);
        }
 
        // lip
        Path2D.Double path = new Path2D.Double();
 
        int lipX = X + (borderWidth / 2) - LIP_OFFSET;
        int lipY = Y + borderHeight;
 
        path.moveTo(lipX, lipY);
        path.lineTo(lipX - LIP_WIDTH, lipY + LIP_HEIGHT);
        path.lineTo(lipX - LIP_WIDTH, lipY);
 
        g2d.setColor(Color.WHITE);
        g2d.fill(path);
        g2d.setColor(Color.BLACK);
        g2d.draw(path);
 
        return resultImage;
 
    }
 
}

So verwendet man die Klasse

1

Image bubbleImage = BubbleFactory.buildBubble("Ich liebe die\n Sprechblasen von\niluZio.de!");

“Hallo Welt!” auf der grünen Wiese

Wir wenden uns wieder dem Vergleich mit der grünen Wiese zu. Wir wollen ein ganz neues Programmier-Projekt starten, das “Hallo Welt!”-Projekt. Wir stehen also hier auf der Wiese, nichts ist weit und breit zu sehen. Das bedeutet, dass wir einen neuen, leeren Unterordner in unserem bereits angelegten “Projekte”-Ordner anlegen. Dieses neue Verzeichnis nennen wir beispielsweise “Hallo_Welt”. Dann stellen wir den Zaun auf, in den nur wir als Programmierer hinein dürfen. Hiermit ist gemeint, dass wir in unserem bisher leeren Verzeichnis eine neue Textdatei anlegen. Das machen wir, indem wir einen Editor öffnen und von da aus die “Speichern”-Funktion ausführen. Diese neue Datei soll “HalloWelt.java” heißen. “HalloWelt” beschreibt, worum es in dieser Datei geht, und “.java” macht klar, dass es sich hierbei um Befehle in der Programmiersprache Java handelt.

Output mit Schreibmaschine und Greifarm

Was hat es mit dem “Hallo Welt!”-Programm auf sich? Um bei unserem Vergleich zu bleiben, ist “Hallo Welt!” folgendermaßen zu verstehen: Wir bauen uns innerhalb des Zauns eine Konstruktion zurecht, die, vielleicht mit einem Roboter an einer Schreibmaschine, “Hallo Welt!” auf ein Stück Papier tippt. Ein Greifarm nimmt dann das Papier von der Schreibmaschine und legt es auf das Output-Förderband, das Dinge durch eine der beiden Lücken im Zaun nach draußen transportiert. Diese Aufgabe (Papier beschriften und auf das Förderband legen) wird genau dann ausgeführt, wenn der Benutzer außen den roten Knopf betätigt.

Aus Sicht des Benutzers ist dies ja alles in allem schon eine recht interessante Maschine: Er drückt auf den Knopf, und ein Stück “Hallo Welt!”-beschriftetes Papier kommt heraus. Man könnte also sagen, das Programm begrüßt die Welt auf Knopfdruck. Der Benutzer kann so oft auf den Knopf drücken, wie er möchte. Da es Zauberpapier ist, wird es nie ausgehen, und auch der Roboter wird nie des Tippens müde. Es wird immer wieder ein Stück “Hallo Welt!”-Papier herauskommen.

Java-Befehle schreiben

Hier kommen wir nun also zu den ersten Java-Befehlen (die Zeilennummern gehören nicht dazu, nur der Text):

1
2
3
4
5

public class HalloWelt {
    public static void main(String[] args) {
         System.out.println("Hallo Welt!");
    }
}

Wie versprochen werde ich alle Details des Programmierens, also auch diese ersten fünf Zeilen Java-Befehle, Zeichen für Zeichen, Wort für Wort, ganz genau und in allen Einzelheiten erklären. Es ist ganz normal, dass das wie verrücktes Kauderwelsch aussieht, wenn man der Sprache Java noch nie begegnet ist. Aber im Laufe der nächsten Artikel wird das alles klar und absolut verständlich werden. Versprochen!

Fürs Erste müssen wir diese fünf Zeilen Java-Befehle allerdings ohne Kenntnis deren genauer Bedeutung mit dem Editor in die Textdatei “HalloWelt.java” schreiben und speichern die Datei ab.

Die Java-Befehle übersetzen

Wir wollen nun diese Java-Befehle, bzw. die Datei, in der sie abgespeichert sind, übersetzen, und zwar in die Java-Zwischensprache.
Für den Anfang gibt es hierfür eine einfache Möglichkeit. Und zwar haben wir ja das JDK installiert, bei dem Werkzeuge dabei sind, die ein Programmierer für seine tägliche Arbeit braucht. Eines dieser Werkzeuge ist genau für die Arbeit gedacht, die wir gerade vor uns haben, und zwar ein Java-Übersetzungs-Programm. Dieses Programm, das man “Übersetzer” oder “Compiler” nennt, ist ein Kommandozeilen-Programm. Es wurde mit dem JDK auf dem Computer installiert und wird deshalb nicht Kommando genannt, weil es nicht von Anfang an in der Kommandozeile verfügbar war.

Um unsere Java-Datei zu übersetzen, müssen wir zuerst mit dem Kommando “cd” in das Verzeichnis unseres Projektes navigieren. Die Kommandos, die man jetzt ausführen muss, sind natürlich immer unterschiedlich, je nach dem wo man gerade in der Konsole “steht” (welches das aktuelle Arbeitsverzeichnis in der Konsole ist) und wo wir das Projekte-Verzeichnis angelegt haben.

C:\Dokumente und Einstellungen\Stefan

cd Eigene Dateien
cd Projekte
cd Hallo_Welt

/home/Stefan

cd Projekte
cd Hallo_Welt

Wenn wir jetzt in dem “Hallo_Welt”-Ordner stehen, dann müsste ein “dir” bzw. ein “ls” uns genau eine Datei anzeigen, und zwar “HalloWelt.java”. Diese hatten wir zuvor mit dem Editor hier abgespeichert.

Jetzt ist nur noch eine weitere Eingabe nötig, um die Übersetzung vorzunehmen:

javac HalloWelt.java

Erklärung: “javac” ist das Java-Übersetzungs-Programm, von dem weiter oben die Rede war. “javac” steht für “java compiler” (“Java Übersetzer”). Nach einem Leerzeichen muss der volle Name der Datei angegeben werden, die wir übersetzen wollen (“HalloWelt.java”). Hat dies ohne Fehlermeldung funktioniert, sehen wir nach einem “dir” bzw. “ls”, dass plötzlich eine zweite Datei zu der von uns erstellen Datei “HalloWelt.java” hinzu gekommen ist. Diese Datei heißt “HalloWelt.class”. Sie wurde vom Compiler “javac” angelegt. Unsere Ursprungs-Datei “HalloWelt.java” wurde vom Compiler nicht verändert und liegt nach wie vor an der Stelle, an der wir sie angelegt haben.
Übrigens kann dieser Übersetzungs-Schritt beliebig oft durchgeführt werden. Die .class-Datei wird dann dabei immer wieder überschrieben.

Die Zwischensprache

Die neue Datei “HalloWelt.class” ist die übersetzte Variante von “HalloWelt.java”. Spaßeshalber können wir die neu angelegte .class-Datei einmal mit dem Editor öffnen. Wie bereits gelernt, arbeitet man bei Java so, dass die Java-Befehle erst in eine Zwischensprache und dann in Maschinensprache übersetzt werden. Dieser soeben getätigte Schritt mit dem Compiler war der Übersetzungs-Vorgang von Java nach Zwischensprache. Im Editor sehen wir, dass wir nichts sehen. Unschwer ist zu erkennen, dass schon diese Zwischensprache nichts mehr ist, was ein Mensch verstehen können soll oder muss. Mit den vielen Sonderzeichen und unleserlichen Blöcken ähnelt die Zwischensprache viel mehr der Maschinensprache als unseren Java-Befehlen.

Das Programm ausführen

Nun also ist jetzt noch das zu tun, worauf wir die ganze Zeit schon gewartet haben. Wir wollen uns in die Rolle eines Benutzers begeben und bei unserer “Hallo Welt!”-Konstruktion auf den roten Knopf drücken. Dies geschieht, wenn wir folgendes in der Kommandozeile eingeben:

java HalloWelt

Achtung: Diesmal lautet das Programm, dass wir starten nicht “javac”, sondern “java”. Und wir schreiben nach “java” genau “HalloWelt”, nicht etwa “HalloWelt.java”, oder HalloWelt.class”. Wenn wir bis zu dieser Stelle alles richtig gemacht haben, sollte nach unserer Eingabe von gerade eben genau folgendes in die Kommandozeile geschrieben werden:

Hallo Welt!

Danach müsste in der Konsole der blinkende Cursor wieder auf neue Eingaben warten. Ein kleiner Schritt für einen Benutzer, aber ein großer Schritt für die Programmierer-Menschheit!

Was ist hier geschehen? Das zweite Programm, das wir gerade aus dem JDK kennen gelernt haben, heißt “java”. Wie der Name vielleicht schon vermuten lässt, ist dies das zentralste und wichtigste aller Programme aus dem Java-Umfeld. Damit lassen sich Programme, die in der Java-Zwischensprache vorliegen, in einem einzigen Schritt in Maschinensprache übersetzen und sofort ausführen. Dieses Programm ist übrigens genau so auch in der JRE vorhanden, weil es auch von Benutzern gebraucht wird, die Programme lediglich ausführen wollen und deshalb kein JDK brauchen.

Benutzer und die Kommandozeile

Vielleicht ist bereits die Frage aufgetaucht, ob sich ein Benutzer zum Starten eines Java-Programms immer in die Kommandozeile begeben muss, um Dinge wie

java HalloWelt

einzugeben, um ein Programm zu starten. Diese Befürchtung liegt nahe, weil wir das ja gerade auch getan haben, und wir waren ja eben in der “Benutzer-Rolle”. Die Antwort: Nein, ein Benutzer wird das nicht tun müssen. Unser kleines Programm liegt allerdings gerade in der “Roh-Fassung” vor und lässt sich zum jetzigen Zeitpunkt nur so starten. Später allerdings, wenn es fertiggestellt ist, kann es auf einem anderen Computer installiert werden und ist dann beispielsweise über ein Anwendungs-Menü aufzurufen, wie jedes andere Programm auch.

Hallo schöne Java-Welt!

Gegen Ende dieses Artikels, bzw. nachdem das Wichtigste in diesem Artikel schon besprochen wurde, nämlich das “Hallo Welt!”-Programm, möchte ich die Gelegenheit nutzen, um zwei Kleinigkeiten zu demonstrieren, die die Punkte, die wir durchlaufen haben, vertiefen bzw. verdeutlichen sollen.

Erstens werden wir eine kleine Änderung in unserer .java-Datei vornehmen. Wir haben der Tradition zuliebe das ehrwürdige “Hallo Welt!”-Programm geschrieben und der Pflicht damit genüge getan. Jetzt aber sind wir damit fertig und verändern das Programm.

Bei genauerer Betrachtung von Zeile 3 erkennen wir die Worte “Hallo Welt!”. Es sind exakt die Worte, die beim Starten des Programms in die Kommandozeile geschrieben wurden:

1
2
3
4
5

public class HalloWelt {
    public static void main(String[] args) {
         System.out.println("Hallo Welt!");
    }
}

Wir verändern diese Zeile jetzt so, dass danach “Hallo schöne Java-Welt!” steht. Das sollte dann so aussehen:

1
2
3
4
5

public class HalloWelt {
    public static void main(String[] args) {
         System.out.println("Hallo schöne Java-Welt!");
    }
}

Was in den anderen Zeilen, bzw. vor oder nach “Hallo schöne Java-Welt!” steht, lassen wir unverändert. Dann übersetzen wir erneut mit folgender Eingabe:

javac HalloWelt.java

Und dann starten wir das Programm nochmal mit:

java HalloWelt

Das waren genau die selben Eingaben, die wir bereits getätigt haben. Jetzt sollte

Hallo schöne Java-Welt!

in die Kommandozeile geschrieben werden. Damit möchte ich wiederholt verdeutlichen, dass wir mit allem, was wir mit diesen und weiteren Java-Befehlen formulieren, bestimmen können, was unser Programm tut.

Zweitens möchte ich an dieser Stelle noch einmal den Unterschied von Programmierer und Benutzer, diesmal aber von technischer Seite her überdeutlich klarstellen. Dazu machen wir in der Kommandozeile nochmals folgende Eingabe:

java HalloWelt

Diese Eingabe machen wir in der Rolle des Benutzers, und wir sollten wieder unsere Konsolen-Ausgabe sehen. Jetzt löschen wir die Datei “HalloWelt.class”, die vom “javac”-Programm erzeugt wurde, und machen erneut folgende Eingabe:

java HalloWelt

Die exakt gleiche Eingabe erzeugt nun im Normalfall so eine Fehlermeldung:

Exception in thread "main" java.lang.NoClassDefFoundError: HalloWelt
Caused by: java.lang.ClassNotFoundException: HalloWelt
	at java.net.URLClassLoader$1.run(URLClassLoader.java:202)
	at java.security.AccessController.doPrivileged(Native Method)
	at java.net.URLClassLoader.findClass(URLClassLoader.java:190)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:306)
	at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:301)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:247)
Could not find the main class: HalloWelt.  Program will exit.

Es wird deutlich: Ist die .class-Datei weg, kann das Programm nicht mehr wie zuvor gestartet werden, weil das Programm nicht übersetzt vorliegt.
Deswegen übersetzen wir das Programm jetzt wieder, in der Rolle des Programmierers:

javac HalloWelt.java

Die .class-Datei ist wieder da, jetzt kann ein Benutzer das Programm auch wieder mit

java HalloWelt

starten. Um das ganze noch ins Extrem zu treiben, löschen wir zu Testzwecken jetzt auch einmal die Datei “HalloWelt.java”, also unsere Java-Befehle. Normalerweise würden wir das nicht tun. In die Java-Befehle ist unsere kreative Arbeit geflossen (unsere Konstruktion!), und die ist nach dem Löschen von .java-Dateien üblicherweise verloren. Jetzt sind es allerdings nur 5 Zeilen, die in diesem Artikel ja noch einfach nachzulesen sind. Das Übersetzen mit folgender Eingabe:

javac HalloWelt.java

ist jetzt verständlicherweise nicht mehr möglich. Wir bitten das Programm “javac” uns die Datei “HalloWelt.java” zu übersetzen, diese ist aber gar nicht da: das kann nicht funktionieren. Die Fehlermeldung:

javac: file not found: HalloWelt.java
Usage: javac <options> <source files>
use -help for a list of possible options

An dieser Stelle ist aber interessant und äußerst wichtig zu wissen: In unserer Benutzer-Rolle können wir trotzdem noch das Programm starten. Die Eingabe:

java HalloWelt

sollte uns die gleiche Ausgabe wie vorher bescheren:

Hallo schöne Java-Welt!

Hier wird also klar, dass der Benutzer zum Starten des Programms lediglich die .class-Datei, also das Programm in der Zwischensprache benötigt, nicht aber die .java-Datei, unsere Java-Befehle. Eine Rückwärts-Übersetzung von Zwischensprache nach normale Java-Befehle ist übrigens nur unter äußersten Umständen und in begrenztem Umfang möglich. In vielen Fällen ist dies gar nicht gewünscht und kann deshalb auch gezielt verhindert werden.

Fazit

In diesem Artikel haben wir das “Hallo Welt!”-Programm kennen gelernt. Wir haben dazu die Java-Befehle in eine Datei geschrieben. Diese haben wir mit dem Programm “javac” übersetzt, wo wir in diesem Schritt die Java-Zwischensprache in Form einer .class-Datei erhalten haben. Mit dieser und mit dem Programm “java” konnten wir das Programm so als Benutzer starten.
Auch haben wir das Programm schon einmal verändert und neu übersetzt und ausgeführt. Des Weiteren wurde erklärt, dass ein Benutzer nur die .class-Datei braucht, um das Programm zu starten. Diese Datei kann aber nur von einem Programmierer mit “javac” aus dem JDK erzeugt werden, da nur der Programmierer die Java-Befehle in Form einer .java-Datei besitzt, und nur er das JDK installiert hat.

Der Editor

Ein Editor ist vergleichbar mit einem Textverarbeitungsprogramm (Microsoft Word, OpenOffice Writer, LibreOffice Writer). Man kann darin Text schreiben (editieren) und in Dateien abspeichern. Der Text in einem Editor ist nicht dazu gedacht, ausgedruckt zu werden. Deshalb gibt es keinen Seitenumbruch, sondern es kann beliebig weit nach unten geschrieben werden. Es ist, als wäre die Seite, auf die man schreibt, unendlich lang. Und auch in die Zeilenbreite, also nach rechts, gibt es keine Begrenzung.

Was man in einem Editor nicht macht, ist den Text zu formatieren, also etwa Schriftarten, Schriftgrößen oder Farben zu ändern. Daran erkennt man schon, dass es in einem Editor nicht um Design und Gestaltung geht, sondern rein um den Inhalt des Textes. Man nennt sie deshalb auch Texteditoren.

Meistens ist in einem Texteditor eine so genannte “nichtproportionale” Schriftart eingestellt, z. B. “Courier New”. Das bedeutet, der Buchstabe “i” ist genau so breit wie ein “m”, anders als dies bei einer “proportionalen” Schriftart der Fall ist. Der Grund hierfür ist die größere Übersichtlichkeit im Programmiersprachen-Text.

Befehle formulieren

Wir haben bereits gelernt, dass programmieren bedeutet, Befehle in einer Programmiersprache zu formulieren. Diese Befehle sagen genau aus, was der Zweck des Programms ist, was das Programm machen soll. Bisher war jedoch nicht klar, wie das genau geht: Wir müssen Befehle in der Programmiersprache Java als Text formulieren und in einem Texteditor niederschreiben. Diesen Text speichern wir dann in eine Datei ab. So können wir den Text jederzeit wieder verändern, wenn wir später eine Änderung am Programm vornehmen wollen. Genau dieser Text ist es, bzw. die Datei, in der dieser Text abgespeichert wurde, der dann in Maschinensprache, bzw. bei Java erst in eine Zwischensprache, dann in Maschinensprache, übersetzt wird.

Von Java-Befehlen zum ausführbaren Programm

So wird der Arbeitsvorgang langsam klarer: Der Programmierer schreibt Java-Befehle in einem Texteditor, speichert diese in eine Datei ab, die Datei wird in eine Zwischensprache übersetzt, an den Benutzer gegeben, der Benutzer übersetzt die Zwischensprache beim Starten des Programms automatisch in Maschinensprache, das Programm kann so ausgeführt werden.

Verschiedene Editoren

Es gibt viele verschiedene Texteditoren. Auf jedem Betriebssystem (Windows, Linux, MacOS, etc.) ist bereits mindestens ein Texteditor vorhanden, den wir für den Anfang auf jeden Fall verwenden können.

Ein Beispiel-Befehl

An dieser Stelle öffnen wir zum ersten Mal einen Editor. Es ist meistens ein Fenster mit einem weißen Textbereich, der den größten Teil des Fensters einnimmt. Oben gibt es fast immer ein Menü mit Einträgen wie “Datei”, “Bearbeiten”, “Ansicht” usw…
Wie in einem Textverarbeitungsprogramm kann man auch in einem Texteditor schreiben was man möchte. Ein Editor ist nämlich nicht speziell ein Programmier-Werkzeug. Es kann auch für die Einkaufsliste, ein Tagebuch oder beliebige andere Informationen in Textform verwendet werden. Auch viele Dateien, mit denen man ein Betriebssystem verwalten kann, werden üblicherweise mit Texteditoren bearbeitet.

Tippen wir doch einfach mal einen Befehl in den Editor ein:

Computer, ich befehle Dir, addiere die Zahlen 3 und 5,
und schreibe das Ergebnis in die Kommandozeile.

Diesen Befehl haben wir nun in “Deutsch”, nicht in “Java” formuliert. Das folgt erst im nächsten Schritt. Aber immerhin steht schon ein Befehl im Editor. Und diesen wollen wir jetzt in eine Datei abspeichern. Dazu wählen wir oben im Menü den Punkt Datei > Speichern. Es öffnet sich ein “Speichern”-Fenster, weil der Editor wissen möchte, in welchem Ordner die Datei abgespeichert werden soll, und wie die Datei heißen soll.

Speicherort und Dateiname

Für jedes Programm, das wir entwickeln, sollten wir einen eigenen Ordner anlegen, weil jedes Programm auf seiner ganz eigenen grünen Wiese entwickelt wird. Alle Dateien, die mit dem Programm zu tun haben, werden in diesem Ordner abgelegt. Dazu gehören sowohl die Befehls-Dateien, die bei uns in der Programmiersprache Java geschrieben sind, als auch alle anderen Dokumente, die der Programmierer zur Erstellung des Programms benötigt. Das könnten Text- und Tabellen-Dokumente sein, die zur Planung des Programms verwendet werden. Aber es werden auch beispielsweise Grafiken und Musik-Dateien in diesem Ordner abgelegt, die dann direkt im Programm eingebaut werden, z. B. in einem Spiel.
Es gibt keine Vorgabe, wo auf dem Computer der Ordner erstellt werden muss. Ein “Projekte”-Ordner, der alle zukünftigen Programm-Projekte beinhaltet, ist eine gute Idee. Dieser könnte dann unter Windows in den “Eigenen Dateien” liegen (“Persönlicher Ordner” oder “Home” unter Linux, “Benutzerordner” unter MacOS). Also legen wir diesen “Projekte”-Ordner jetzt an. Darin legen wir noch einen Unterordner “ErstesProjekt” an. Leerzeichen in Ordnernamen, sowie auch in Dateinamen, sind zwar erlaubt, aber vor Allem bei der Arbeit mit der Kommandozeile ist dies hinderlich und schafft unnötige Probleme. Deshalb sollten wir aus Gründen der Leserlichkeit statt Leerzeichen an entsprechenden Stellen Unterstriche oder “camel case” verwenden. “Camel case” bedeutet, Wörter so zusammen zu setzen, dass innerhalb eines Wortes mit einem Großbuchstaben begonnen wird, wie bei “ErstesProjekt”.

Als Dateinamen wählen wir für unser obiges Beispiel “ZweiZahlenAddieren.deutsch” aus. “ZweiZahlenAddieren” drückt ganz einfach den Zweck des Programms mit “camel case” aus, gefolgt von “.deutsch”. Dies wird “Dateiendung” oder “Dateinamens-Erweiterung” genannt. Allgemein ist eine Dateiendung dazu gedacht, zu beschreiben, um was für eine Datei es sich handelt, ohne dass man sich den Inhalt der Datei anschauen muss. Beispiele: Einfache Text-Dateien haben oft die Dateiendung “.txt”, also z. B. “Tagebuch.txt”. Microsoft Word-Dokumente heißen fast immer “.doc”, es gibt Videos, die mit “.mov”, für “Movie”, enden. Bei Dateien, die Programmiersprachen-Befehle enthalten, hat es sich eingebürgert, dass die Datenendung die Sprache bezeichnet, die die Datei enthält. Wir werden also viel mit “.java”-Dateien zu tun haben. Die Programmiersprache “C” ist immer in “.c”-Dateien zu finden, Pascal wird in “.pas”-Dateien abgespeichert. Um diese Konvention konsequent zu verwenden, und dass wir uns jetzt schon einmal daran gewöhnen, heißt unsere Beispiel-Datei “ZweiZahlenAddieren.deutsch”, weil der Befehl in Deutsch geschrieben ist.

Fazit

Wir wissen nun, was ein Editor, bzw. ein Texteditor ist, und wozu man ihn braucht. Wir haben sogar schon eine erste Datei damit angelegt, die einen Programmiersprachen-Befehl enthält, allerdings in Deutsch, nicht in Java.

Die Kommandozeile

Jetzt endlich ist es an der Zeit, die Kommandozeile kennen zu lernen. Diese wird oft auch “Terminal” oder “Konsole” genannt, also falls diese Begriffe in Zukunft auftauchen, ist damit immer die Kommandozeile gemeint. Mit Hilfe der Kommandozeile können ganz bestimmte Programme, nämlich Kommandozeilen-Programme gestartet und bedient werden. Beispiel: Unser erstes Programm, das “Hallo Welt!”-Programm ist ein Kommandozeilen-Programm und wird deshalb im Rahmen einer Kommandozeile laufen. Rein prinzipiell könnte man ein Kommandozeilen-Programm auch außerhalb einer Kommandozeile ausführen. Nur dann wäre es dem Benutzer nicht möglich das Programm zu bedienen. Genau für diesen Zweck wird nämlich die Kommandozeile gebraucht: als Umgebung, um mit den Programmen, die in ihr laufen, Input und Output auszutauschen. Der Vollständigkeit halber möchte ich erwähnen, dass es eine Gattung von Programmen gibt, die tatsächlich ohne Dateneingabe und -ausgabe ihre Arbeit verrichten, so genannte Dienstprogramme. Das sind zumeist Betriebssystem-Programme, die im Hintergrund laufen und z. B. die Computer-Hardware überwachen. Solche Dienstprogramme sind in der Tat Kommandozeilen-Programme, die nicht in einer Kommandozeile laufen, sie sind aber eine Ausnahme.

Eine Kommandozeile öffnen

Wir werden jetzt einfach eine Kommandozeile starten. Auf jedem Betriebssystem hat sie einen anderen anderen Namen und ist an einer anderen Stelle in den Menüs zu finden.

Die Kommandozeile ist zumeist ein Fenster mit dunklem/schwarzem Hintergrund und heller/weißer Schrift. Irgendwo sollte ein Cursor blinken, dann ist die Kommandozeile (das Terminal) bereit, Benutzereingaben aufzunehmen.

Das erste Programm starten

Um ein beliebiges Programm im Rahmen des soeben geöffneten Terminals zu starten, gibt man einfach über die Tastatur den Namen eines Programms ein, gefolgt von einem Betätigen der Enter-Taste. Da wir selbst noch kein Programm erstellt haben, werden wir jetzt zu Anschauungs-Zwecken ein bereits existierendes Programm starten, das bei der Installation des Betriebssystems mitgeliefert wurde. Wir geben also mit der Tastatur folgendes ein:

help

Nach dieser Eingabe betätigen wir die Enter-Taste. Das Programm “help” spuckt einen ganzen Schwung an Text aus. Darunter (nach dem Text) sollte wieder der Cursor blinken.

Was ist hier passiert? Wir haben mit unserer Eingabe von “help” und der Enter-Taste sinnbildlich auf den roten Knopf des existierenden Programms “help” gedrückt. Dieses hat uns eine ganze Menge Text auf das Output-Förderband gelegt, den wir über die Kommandozeile angezeigt bekommen haben. Input hat “help” von uns nicht erhalten. Da der angezeigte Output der einzige Zweck, die einzige Funktion, von “help” ist, hat sich das Programm danach wieder beendet. Das sehen wir daran, dass in der Kommandozeile wieder der Cursor blinkt, was bedeutet, dass wir wieder etwas eingeben können. Zum Beispiel könnten wir “help” noch einmal starten. Es wird wieder der genau gleiche Output dargestellt werden, das ließe sich beliebig wiederholen. Immer wieder könnten wir “help” von Neuem ausführen, es würde einige Zeilen Output in die Kommandozeile schreiben, sofort danach ist help wieder beendet. Jedes erneute Aufrufen von “help” entspricht in unserem Vergleich der grünen Wiese einem neuen Drücken auf den roten Knopf.

Kommandos

Es gibt Programme, wie auch das Programm “help”, die gehören von Anfang an fest zu einer Kommandozeile dazu. Sie sind immer verfügbar, weil sie sozusagen mitgeliefert wurden. Diese Programme nennt man “Kommandos”. Technisch gesehen besteht kein Unterschied zwischen einem Programm und einem Kommando. Kommandos wurden genau wie Programme “programmiert”. Sie tragen nur den Namen “Kommando”, damit man gleich weiß, dass es Programme sind, die zur Kommandozeile gehören, sie sind fest eingebaut.
Manche dieser Kommandos ähneln sich unter Windows, Linux oder MacOS sehr stark, und manche sind in den Kommandozeilen der verschiedenen Betriebssysteme total unterschiedlich. Dabei ist noch zu erwähnen, dass die Kommandos, die wir in dieser Artikel-Serie verwenden, in Linux und MacOS genau gleich sind. Das hat den Grund, dass Linux und MacOS in ihrem Kern verwandte Betriebssysteme sind.
Unsere eigenen Programme, sowohl das “Hallo Welt!”-Programm, das wir zuerst entwickeln, als auch unser Spiel, werden nicht Kommandos genannt. Diese Programme laufen zwar in die Kommandozeile ab, sind aber kein fester Bestandteil dieser.

In der Kommandozeile navigieren

Schauen wir uns einmal den Windows-Explorer, oder auch jeden anderen Datei-Browser wie Nautilus in Linux mit Gnome, den Konquerer unter Linux mit KDE oder beispielsweise Finder unter MacOS, an. Wir sehen, dass man bei der Benutzung immer an einer bestimmten Stelle, an einem bestimmten Ort “steht”. Man nennt dies das “aktuelle Arbeitsverzeichnis”. Es ist der Ordner, den man sich gerade ansieht, also alle Dateien und Unterverzeichnisse, die sich darin befinden. Durch einen Doppelklick auf einen Unterordner “springt” man dorthin, das aktuelle Arbeitsverzeichnis hat sich geändert und ist nun dieser Unterordner. Und meistens gibt es einen “Zurück”-Knopf, mit dem man zum letzten besuchten Verzeichnis zurückkehren kann. Auf diese Weise kann man zu allen Verzeichnissen auf dem Computer navigieren und mit den Dateien arbeiten.

Und genau so gibt es auch in der Kommandozeile dieses “aktuelle Arbeitsverzeichnis”. Meistens wird es vor dem blinkenden Cursor angezeigt. Man kann es sich aber auch mit einem Programm (einem Kommando) anzeigen lassen.

cd

pwd

Genau wie das Kommando “help” schreibt uns “cd” bzw. “pwd” auch etwas in die Kommandozeile, nämlich in welchem Verzeichnis wir uns gerade befinden.
Achtung: Die Verzeichnisse werden unter Windows mit einem rückwärtigen Schrägstrich “\” voneinander getrennt, in Linux und MacOS ist es ein normaler Schrägstrich “/”.

Jetzt kennen wir aber noch nicht den Inhalt dieses aktuellen Arbeitsverzeichnisses. Anders als in einem herkömmlichen Datei-Browser müssen wir es nämlich explizit von dem Kommandozeile anfordern, wenn wir wissen wollen, wie es in dem Verzeichnis aussieht, in dem wir uns gerade befinden. Dafür gibt es ein weiteres Kommando.

dir

ls

Nach Eingabe von “dir” bzw. “ls” erscheinen die Dateien und Unterordner des aktuellen Verzeichnisses.

Das Kommando “dir” bzw. “ls” ist sozusagen unser Auge in der Kommandozeile.

Jetzt müssen wir noch wissen, wie wir das aktuelle Arbeitsverzeichnis in der Kommandozeile ändern, d. h. wie wir zu einem anderen Verzeichnis, z. B. einem Unterordner wechseln können.

cd Bilder

cd Bilder

Wir sind gerade in ein Unterverzeichnis “hineingewechselt”. Um wieder ein Verzeichnis zurück zu wechseln, also eine Verzeichnis-Ebene nach oben, kann man sowohl unter Windows, als auch unter Linux und MacOS folgendes Kommando benutzen:

cd ..

Die zwei Zeichen “..” bezeichnen in der Kommando-Zeile allgemein immer das übergeordnete Verzeichnis, egal wo man gerade steht. Wir werden später auch noch mit anderen Kommandos auf “..” stoßen. Jedenfalls müssten wir mit “cd ..” wieder genau da landen, wo wir vorher waren.

Mit diesen gerade gelernten Kommandos kann man genau wie in einem Datei-Browser durch alle Verzeichnisse auf dem Computer navigieren: Wir können in Verzeichnisse hinein- und wieder zurückwechseln und uns an den Orten, wo wir gerade stehen, den Inhalt anzeigen lassen.

Fazit

In diesem Artikel haben wir gelernt, dass eine Kommandozeile eine Umgebung ist, in der man Kommandozeilen-Programme starten und mit ihnen Input und Output austauschen kann. Wir haben zum Ausprobieren das Programm “help” gestartet und Output erhalten.
Wir wissen auch, dass Programme, die direkt mit der Kommandozeile zu tun haben “Kommandos” heißen, und wir haben ein paar dieser Kommandos kennen gelernt, um in der Konsole navigieren zu können.

Java

Wie bereits erklärt, kann ein Computer im Grunde nur seine Ur-Sprache, die Maschinensprache, verstehen. Alle anderen Programmiersprachen können nur deshalb funktionieren, weil sie wieder in Maschinensprache übersetzt werden. Der Computer wird im Inneren also nie die Java sprechen können. Java dient uns Programmierern nur als Hilfsmittel, weil Java eine schöne und logisch aufgebaute Sprache ist. Die Maschinensprache wiederum ist komplex und unleserlich. Deshalb schreiben wir unsere Programme mit Java lassen diese dann in Maschinensprache übersetzten. So haben wir hinterher ein Programm, das der Computer verstehen kann, ohne dass wir Programmierer selbst die Maschinensprache verstehen müssen.

Auch haben wir gelernt, dass es bei der Erstellung eines Programms zwei Gruppen von Personen gibt. Die einen erstellen (programmieren) das Programm: die Entwickler. Die anderen benutzen das Programm: die Benutzer. Das Übersetzen eines Programms in Maschinensprache ist Aufgabe des Programmierers. Ein Benutzer kann mit dem Programm nur in bereits übersetzter Maschinensprachen-Form etwas anfangen, weil sein Computer nur diese Sprache spricht. Keine Angst, das Übersetzten muss nicht von Hand gemacht werden. Dafür bekommt der Programmierer alles Notwendige an die Hand, man denke an den Werkzeugkoffer auf der grünen Wiese. Das dauert bei kleineren Programmen nur wenige Sekunden. Diese Werkzeuge, um als Programmierer mit Java zu arbeiten, fehlen im Normalfall auf einem herkömmlichen Benutzer-Computer und müssen deshalb noch installiert werden. Darum geht es in diesem Artikel.

Die Übersetzung

Bei Java (wie auch bei anderen modernen Programmiersprachen) gibt es noch eine wichtige Besonderheit: Auch zum Starten von Programmen, die mit Java erstellt wurden, muss auf dem Computer noch etwas installiert werden, sofern das nicht schon getan wurde. Warum ist das so? Weiter oben habe ich erklärt, dass Programme in einer bestimmten Programmiersprache (bei uns Java) vom Programmierer in Maschinensprache übersetzt werden, und dass dieses übersetzte Programm von einem Benutzer, bzw. dessen Computer direkt verstanden werden kann, weil der Computer Maschinensprache versteht. Das ist auch richtig. Bei Programmiersprachen wie beispielsweise C, C++ und Pascal wird es genau so gemacht.

Tatsache ist aber, dass Java-Programme nicht auf direktem Weg in Maschinensprache übersetzt werden, sondern erst über einen Umweg in eine so genannte Zwischensprache. Das Programm wird in dieser Zwischensprache an den Benutzer gegeben. Dieser braucht dann wiederum auch ein Werkzeug, um den zweiten und letzten Übersetzungs-Schritt von der Zwischensprache zur Maschinensprache zu gehen. Das hört sich komplizierter an, als es tatsächlich ist. In der Realität bekommt der Benutzer von diesem zweiten Übersetzungs-Schritt überhaupt nichts mit. Wenn er ein Programm starten möchte, das mit Java erstellt wurde, geschieht das, wie bei jedem anderen Programm auch, vermutlich über den Doppelklick auf ein Icon auf dem Desktop oder aus einem Programm-Menü heraus. Für ihn unsichtbar wird nun die Übersetzung von Zwischensprache in Maschinensprache vollzogen.

Als kleinen Blick über unseren Java-Tellerrand möchte ich erklären, dass sich die Programmiersprachen in dieser Hinsicht so in drei Gruppen einteilen lassen. Erstens Sprachen wie C, C++, Pascal und viele weitere, die komplett fertig in Maschinensprache übersetzt an den Benutzer gegeben werden. Des Weiteren Sprachen wie Java und die .NET-Sprachen von Microsoft, die in Form einer Zwischensprache beim Benutzer ankommen und dort in einem zweiten Schritt in Maschinensprache übersetzt werden. Die dritte Gruppe von Programmiersprachen wurden bisher noch nicht erwähnt. Hierzu zählen beispielsweise BASIC, PHP und noch einige mehr. Diese Sprachen werden überhaupt nicht übersetzt, sondern landen unübersetzt beim Benutzer. Erst beim Starten des Programms auf dem Benutzer-Computer findet eine Übersetzung statt.
Jede dieser drei Gruppen hat durch ihre ganz einzigartige Technik Vor- und Nachteile, die sich im Laufe der Zeit als Programmierer noch herausstellen werden. Nur so viel sei gesagt: Java, sowie auch die .NET-Sprachen, geht mit dem Zwischenschritt der Übersetzung zu einer Zwischensprache einen gut ausbalancierten Mittelweg.

JRE oder JDK

Für diese beiden Anwendungsgebiete im Java-Umfeld, für Benutzer oder Programmierer, gibt es zwei unterschiedliche Pakete, die auf einem Computer installiert werden können: JRE oder JDK.

JRE steht ausgeschrieben für Java Runtime Environment (Java Laufzeitumgebung). Die Laufzeitumgebung ist banal ausgedrückt eine Umgebung, um Java-Programme laufen zu lassen, also zu verwenden. Genauer ausgedrückt kann die JRE Programme, die in der Java-Zwischensprache vorliegen, in die Maschinensprache übersetzen. Folglich ist die JRE das Modul für Benutzer.

JDK bedeutet Java Development Kit (Java Entwickler-Austattung). Wie der Name hier schon genau ausdrückt, ist das JDK die Austattung, die ein Java-Entwickler braucht. Es enthält die Funktion, Java-Programme in die Java-Zwischensprache zu übersetzen, die dann an Benutzer weiter gegeben werden kann.
Weil die Entwickler auch gleichzeitig die Benutzer ihrer eigenen Programme sind, ist es nur logisch und sinnvoll, dass die Entwickler-Austattung auch eine vollwertige Laufzeitumgebung enthält. Installiert man also ein JDK, ist eine JRE automatisch mit dabei.

JDK installieren

Sowohl die JRE, als auch das JDK, kann ganz einfach installiert werden. Die genaue Installations-Vorgehensweise ist allerdings von Betriebssystem zu Betriebssystem unterschiedlich.

Ab hier kommt es in dieser Artikel-Serie öfters vor, dass sich Erklärungen und Beschreibungen von einem Betriebssystem zum anderen unterscheiden. Drei Gruppen von Betriebs-Systemen werden berücksichtigt: Windows, Linux und MacOS. Die betreffenden Stellen mit unterschiedlichem Inhalt werde ich farblich markieren. Windows bekommt die Farbe blau, Linux und MacOS teilen sich die Farbe grün. Das hat den Grund, dass viele Erklärungen, jedoch nicht alle, für Linux und MacOS zusammengefasst werden können.
Natürlich reicht es, nur den Text des eigenen Betriebssystems zu lesen. Schaden kann es aber sicher nicht, zumindest ab und zu einmal in die anderen Betriebssysteme rein zu schnuppern. Zu neugierig kann man beim Programmieren eigentlich nie sein.

Und hier haben wir schon den ersten Fall:

Fazit

Wir haben Java auf unserem Computer installiert, und zwar die Variante von Java, mit der wir neue Programme erstellen können (JDK), nicht nur bereits bestehende Programme starten (JRE).

Input und Output

Ein Beispiel: In einem Internet-Browser gibt es oben eine Adresszeile, in die der Benutzer die Adresse einer Internet-Seite eingeben kann, zu der er gerne navigieren möchte. Diese Adress-Zeile ist ein Eingabe-Element, womit eine Information in das Programm “eingegeben” werden kann. Dieser Vorgang nennt sich “Input”. Mit diesem Input ruft der Benutzer eine Funktion des Internet-Browsers auf, und zwar die Navigation zu eben genau dieser Internet-Seite. Der Browser führt die Funktion aus und stellt dann die gewünschte Internet-Seite im großen Anzeigefeld dar, das die größte Fläche im Layout des Browsers einnimmt. Das wiederum nennt man “Output”.
Aus dieser Kombination von Input und Output ergibt sich, wie man das Programm bedient. Ein Benutzer gibt Daten in ein Programm ein und betätigt über Schaltflächen bestimmte Funktionen des Programms (Input). Das Programm führt intern seine Funktionen aus und stellt Daten und Ergebnisse dar (Output). Damit kann der Benutzer dann weiterarbeiten und ggf. neue Daten eingeben und andere Funktionen aufrufen, die wiederum Output erzeugen.

An dieser Stelle kehren wir wieder einmal kurz zum Vergleich der grünen Wiese zurück. Da war nämlich von zwei Lücken im Zaun die Rede. Durch jede dieser zwei Lücken ist ein Förderband angebracht. Eines ist so eingestellt, dass es Dinge nach außerhalb des Zauns transportiert, das andere läuft in die Richtung, dass es Dinge nach innen transportiert. Diese zwei Förderbänder stellen eine grundlegende Verbindung zwischen innerhalb und außerhalb des Zauns her.
Die Förderbänder stehen sinnbildlich für Input und Output. Ein Benutzer kann etwas auf das Input-Förderband legen und so Daten in das Programm “eingeben”. Das Programm wiederum kann durch das Output-Förderband Daten an den Benutzer “ausgeben”.

Fenster oder Text

Programme lassen sich aus der Sicht eines Benutzers grob in zwei Kategorien einteilen:

Die meisten Programme, die ein durchschnittlicher Benutzer Tag für Tag verwendet, sind Programme, die in einem Fenster ablaufen, also z. B. der Internet-Browser oder ein Taschenrechner-Programm. Programme im Fenster werden auch Programme mit einer “grafischen Benutzerschnittstelle” genannt. Das bedeutet, die “Schnittstelle”, also die Verbindung zwischen den Programm-Funktionen und dem Benutzer, der das Programm bedient, findet auf eine grafische Art und Weise statt. Mit “grafisch” sind hier keine Grafiken/Bilder gemeint, sondern dass das Fenster, in dem das Programm läuft, ein Layout besitzt: Bestimmte Ein- und Ausgabe-Elemente sind sinnvoll angeordnet, wie beispielsweise die Adress-Zeile oder das große Anzeigefeld im Internet-Browser. Diese Ein- und Ausgabe-Elemente sind interaktiv, sie lassen sich mit der Maus anklicken, Menüs können aufgeklappt werden, ein Anzeige-Text kann seine Farbe ändern und weitere Fenster können erscheinen (z. B. ein Fenster mit einer Fehlermeldung oder für Programm-Einstellungen).

Programme der zweiten Kategorie besitzen keine grafische Benutzerschnittstelle. Da es für fast alle Anwendungsgebiete eines normalen Computer-Benutzers Programme mit grafischer Benutzerschnittstelle gibt, führen Programme ohne grafische Benutzerschnittstelle im Leben eines Benutzers ein Schattendasein. Anders sieht dies allerdings für die Programmierung aus. Hier haben solche Programme, nämlich Kommandozeilen-Programme, eine größere Bedeutung. Die Besonderheit von Kommandozeilen-Programmen ist, dass die Dateneingabe durch den Benutzer und die Datenausgabe durch das Programm rein in Textform stattfindet. Was genau die “Kommandozeile” ist und wie sie funktioniert, wird im Folgenden noch genau erklärt.

An dieser Stelle ist wichtig: Grundlegend gibt es keinen Unterschied zwischen der Programmierung eines Programms mit grafischer Benutzerschnittstelle oder eines Kommandozeilen-Programms. Lediglich Stellen im Programm, in denen es um Input und Output, also Dateneingabe und -ausgabe geht, müssen entsprechend anders programmiert werden. Ein Programm besteht aber aus vielen weiteren Teilen. Sieht man von Input und Output ab, gestaltet sich die Programmierung eines Programms mit grafischer Benutzerschnittstelle und eines Kommandozeilen-Programms exakt gleich. Aufgrund dieser Tatsache kann auch nachträglich ein Kommandozeilen-Programm in ein Programm mit grafischer Benutzerschnittstelle “umprogrammiert” werden, ohne dass man das komplette Programm umschreiben muss. Lediglich die Teile, die Input und Output betreffen, müssen umgeschrieben werden.

Wir werden mit Kommandozeilen-Programmierung beginnen. Das ist verglichen mit einer grafischen Benutzerschnittstelle zwar etwas unspektakulär, dafür aber für den Anfang auch viel einfacher. Und wie bereits erwähnt, lässt sich dies später auch leicht umstellen.

Fazit

Wir haben gelernt, dass man Informationen mit einem Programm austauscht, während man es benutzt. Dies wird Input und Output genannt. Bei Kommandozeilen-Programmen findet Input und Output in reiner Textform statt. Bei Programmen, die in einem oder mehreren Fenstern ablaufen, spricht man von Programmen mit grafischer Benutzerschnittstelle.
Das “Hallo Welt!”-Programm ist ein Kommandozeilen-Programm.

Der rote Knopf

Bisher ist bekannt, dass wir sinnbildlich eine Konstruktion innerhalb des Zauns auf unserer Wiese errichten, also Java-Befehle formulieren müssen, um ein Programm zu erhalten. Hier ist es wichtig zu wissen: Wenn wir auf der Wiese eine Konstruktion erfinden und zusammen bauen, so verrichtet diese anfänglich ihre Arbeit erst einmal noch nicht. An der Außenseite des Zauns, ganz in der Nähe der zwei Lücken, die ich bereits erwähnt habe, ist ein roter Knopf angebracht. Die Konstruktion im inneren des Zauns erfüllt ihre Arbeit erst dann, wenn jemand von außen diesen Knopf betätigt. Erst diese Aktion haucht der Konstruktion Leben ein, versorgt sie mit Energie, wenn man so will.

Zuerst denkt sich der Programmierer innerhalb des Zauns eine Konstruktion aus. Diese Konstruktion tut aber noch nichts, der Programmierer konstruiert in der Hoffnung, dass sie später genau das erledigt, was sie soll. Danach muss außerhalb des Zauns auf den roten Knopf gedrückt werden, um die Konstruktion zu aktivieren. Üblicherweise wird auch diese Aufgabe vom Programmierer erledigt. Er begibt sich also nach draußen, drückt auf den roten Knopf und sieht zu, ob die Konstruktion genau das tut, wofür sie erfunden wurde. Wenn sie es tut, freut er sich und begibt sich wieder nach innen, um weiter zu bauen. Die Konstruktion soll ja mit der Zeit immer mehr können. Hat der Programmierer die Konstruktion für eine neue Aufgabe erweitert und angepasst, geht’s wieder nach draußen, um den roten Knopf zu drücken. Erfüllt die Konstruktion die neu hinzu gekommene Aufgabe? Erfüllt sie auch noch ihre bisherigen Aufgaben? Der Programmierer prüft, ob alles stimmt.

Jetzt ist es so, dass Konstruktionen mit der Zeit immer ausgefeilter und komplexer werden. Die Aufgaben, die sie erfüllen sollen, werden schwieriger und dauern länger, bis sie erledigt sind. Vielleicht muss ein Hamster erst einmal 5 Minuten im Laufrad laufen, um das Gummiband soweit aufzurollen, bis es…. usw.
Fehler können sich einschleichen und die Konstruktion macht etwas falsch. Dann begibt sich der Programmierer wieder innerhalb des Zauns und versucht den Fehler zu finden und zu korrigieren. Danach geht’s wieder nach draußen, um den roten Knopf zu drücken. Mit dem Finden von Fehlern und Einbauen neuer Komponenten verbringt der Programmierer seine Zeit. Er wechselt ständig von innerhalb des Zauns nach außerhalb und wieder zurück.

Irgendwann ist aber endlich der Zeitpunkt erreicht, an der die Konstruktion alle Aufgaben, für die sie vorgesehen ist, ohne Fehler ausführt. Dies ist der freudige Augenblick, an dem man einen Nicht-Programmierer, also einen Programm-Benutzer, an den Zaun einladen kann. Dieser soll nun auf den roten Knopf drücken und staunen, was die Konstruktion alles kann! Der Programmierer sieht dem Benutzer vielleicht noch eine Weile zu, irgendwann lässt er ihn dann aber allein am Zaun und legt er sich auf einen Liegestuhl in die Sonne. Sollten dann doch wieder Fehler auftauchen, muss der Programmierer wieder ran. Raus aus dem Liegestuhl und zurück zur Konstruktion! Denn wie bereits gehört, darf nur ein Programmierer innerhalb des Zauns, und nur er hat das nötige Werkzeug, um die Konstruktion zu reparieren.

Fazit

Mit diesem Artikel sollte verdeutlicht werden, dass sich innerhalb des Zauns der Programmierer befindet, und außerhalb des Zauns der Benutzer. Wenn ein Programm allerdings noch nicht fertig ist, wird der Software-Entwickler selbst zum Benutzer, in dem er nach außen geht und auf den roten Knopf drückt, um seine eigene Konstruktion, sein eigenes Programm, auszuprobieren. Somit ist der Programmierer immer der erste Benutzer eines Programms, vor Allem wenn es noch gar nicht fertig ist.

Die grüne Wiese

Mit Vergleichen ist das immer so eine Sache. Oft können sie ein Thema gut veranschaulichen, manchmal stehen Sie einem eher im Weg. Ich möchte an dieser Stelle einen Vergleich anwenden, bei dem hoffentlich überwiegend Ersteres zutrifft.

Stell dir vor, du stehst auf einer großen grünen Wiese. Mit Brettern zäunst einen Bereich ein, und dann stellst du dich innerhalb dieses Bereichs. Der nun eingezäunte Bereich dieser Wiese ist dein Programm. Nur du als Programmierer darfst hinein. Alle anderen müssen draußen bleiben. An zwei Stellen im Zaun machst du die Bretter nicht durchgängig, sondern lässt zwei kleine Lücken frei. Wozu diese Lücken gut sind, werde ich später noch näher erklären. Du hast eine Werkzeugkiste dabei, auf der ein Schriftzug aufgedruckt ist: “Java”. Mit allem, was in der Werkzeugkiste ist, kannst du dich jetzt innerhalb deines Bereichs austoben. Du kannst bauen und basteln…

Mit dem Vergleich der grünen Wiese möchte ich die Brücke zum Programmieren schlagen. Es soll anschaulich gemacht werden, was wir für die Programmierung unseres kleinen Spiels benötigen. Im Folgenden werde ich noch etwas ausführlicher:

Ich habe schon erklärt, dass man dem Computer Befehle geben muss, die ausdrücken, was genau in einem Programm geschehen soll. Diese Befehle müssen in einer Programmiersprache formuliert werden, die in unserem Falle “Java” heißt. Diesen Vorgang, die Formulierung von Befehlen in einer Programmiersprache, nennt man “programmieren”. Der Vergleich mit der Wiese und dem Zaun fordert an dieser Stelle ein klein wenig Vorstellungskraft. Es geht darum, wie die Java-Befehle aussehen würden, wenn man sie auf dieser Wiese mit Werkzeug baute. Ich stelle mir immer eine abenteuerliche Konstruktion aus Zahnrädern, Federn, Gummibändern und all solchen Sachen vor. Vielleicht gibt es roboter-artige Greifarme, Magneten, Sensoren und Hamster in Laufrädern.
All diese Komponenten, die sinnbildlich für unsere Java-Befehle stehen, spielen zusammen und ergeben ein Programm. Viele Einzelkomponenten werden gebraucht, damit das Programm eine komplexe Aufgabe erfüllen kann. Diese Komponenten sind miteinander verbunden und erledigen nur in Zusammenarbeit ihre Pflicht.

Fazit

In diesem Artikel ging es darum, dass man mit vielen kleinen Teilen, nämlich Befehlen in der Sprache Java, einen größeren Zweck erfüllen kann, wenn diese Teile sinnvoll zusammen arbeiten.

Nach ein paar Jahren Abwesenheit soll es hier wieder um Spiele- und Anwendungsentwicklung im weitesten Sinne gehen. Und das in neuem Design, bei dem ich versucht habe, es an das alte anzulehnen:

Viel Spaß!