In dem “Hallo Welt!”-Beispiel haben wir zwei Blöcke vorgefunden, tatsächlich sind dies auch schon zwei unterschiedliche Arten von Blöcken.

Die Methode

An dieser Stelle starten wir mit unserer ersten Block-Art, dem Methoden-Block. In unserem “Hallo Welt!”-Beispiel ist dies der innere Block:

1
2
3
4
5

______ _____ _________ _
    public static void main(String[] args) {
         System.out.println("Hallo Welt!");
    }
_

Die unterschiedlichen Block-Arten erkennt man an ihren Block-Köpfen. Sehen wir uns einmal den Kopf unseres Methoden-Blocks genauer an:

1
2
3
4
5

______ _____ _________ _
    public static void main(String[] args) _
         _________________________ ________
    _
_

Es gibt mehrere Hinweise darauf, woran man erkennen kann, warum dies ein Methoden-Block sein muss. Nicht alle kann ich an dieser Stelle schon einleuchtend erklären, die runden Klammern sind aber der markanteste Hinweis:

1
2
3
4
5

______ _____ _________ _
    ______ ______ ____ ____(________ ____) _
         _________________________ ________
    _
_

Auf die genaue Bedeutung der Klammern werden wir sehr bald noch stoßen. Fürs Erste reicht uns aber die Regel, dass ein Methoden-Block immer zwingend runde Klammern im seinem Block-Kopf haben muss. Ob und was in den runden Klammern geschrieben steht, ist übrigens vorerst noch gleichgültig, die Klammer-Regel gilt mit und ohne Klammer-Inhalt.

Sehen wir uns im Gegenzug dazu einmal den äußeren Block-Kopf an:

1
2
3
4
5

public class HalloWelt _
    ______ ______ ____ _____________ _____ _
         _________________________ ________
    _
_

Hier sind weit und breit keine runden Klammern zu sehen, also kann dies auch kein Methoden-Block sein.

Bedeutung einer Methode

In allgemeinen Sprachgebrauch wird das Wort “Methode” oft verwendet wie “Strategie” oder “Taktik”. In Java ist damit eher eine Arbeitsweise bzw. ein Vorgehen gemeint. Damit soll ausgedrückt werden, dass in einer Methode die eigentliche Arbeit eines Programms verrichtet wird. Alle sinnbildlichen Konstruktionen aus Greifarmen, Schreibmaschinen, Robotern und Zahnrädern, die die Funktion eines Programms bilden, werden wir in Zukunft immer in Methoden-Blöcken aufbauen.

Methoden-Namen

Manchen Blöcken muss man einen Namen geben, so auch Methoden-Blöcken. Das macht man deshalb, weil es später nicht nur eine Methode (wie beim “Hallo Welt!”-Beispiel), sondern mehrere Methoden geben kann und wird. Wir erinnern uns daran, dass wir mehrere Schachteln in eine “Über”-Schachtel stecken können. Um diese voneinander unterscheiden zu können, werden sie namentlich getrennt, sozusagen beschriftet. Es darf nie zwei Methoden-Blöcke mit dem selben Namen geben.

Der Name einer Methode ist immer das Wort vor den runden Klammern im Kopf der Methode:

1
2
3
4
5

______ _____ _________ _
    ______ ______ ____ main(________ ____) _
         _________________________ ________
    _
_

In diesem Fall heißt die Methode “main”.

Eigentlich kann der Programmierer den Namen der Methode bestimmen, er hat die freie Wahl. Lediglich sollte die Methode mit einem kleinen Buchstaben beginnen und nur aus einem Wort bestehen, d. h. keine Leerzeichen oder Zeilenumbrüche sind hier erlaubt. Es folgt ein Beispiel für eine Methode mit einem anderen Namen:

1
2
3
4
5

______ _____ _________ _
    ______ ______ ____ beispielFürEineWeitereMethode() _
         _________________________ ________
    _
_

Der rote Knopf hautnah

Es gibt einen Grund dafür, warum die Methode im “Hallo Welt!”-Beispiel keinen willkürlich gewählten Namen trägt, sondern “main” heißt. Das letzte Code-Beispiel, in dem wir einen eigenen Namen für die Methode vergeben haben, lässt sich ohne Weiteres mit “javac” in die Java-Zwischensprache übersetzen. Das bedeutet, auch mit dem geänderten Methoden-Namen ist es ein gültiger Java-Quelltext.
Gestartet werden kann dieses Programm jedoch nicht.

Gehen wir gedanklich wieder einmal zur grünen Weise und dem Zaun zurück. Ich habe ja erklärt, dass die Konstruktion mit Energie versehen wird, wenn der Benutzer von außen auf den roten Knopf am Zaun drückt. Was wir bisher nicht gewusst haben, ist, was in diesem Moment ganz genau passiert. Da wir jetzt aber schon die Methoden kennen, können wir diesen Vorgang wieder ein Stück genauer betrachten: Der rote Knopf am Zaun ist direkt mit der “main”-Methode des Java-Programms verbunden. Es kann zwar später mehrere Methoden mit unterschiedlichen Namen geben, möchte der Benutzer allerdings auf den roten Knopf drücken, kann damit nur eine ganz bestimmte Methode, die “main”-Methode (zu deutsch, “Hauptsache”), aktiviert werden. Wenn es keine Methode mit diesem bestimmten Namen gibt, ist der rote Knopf ohne Funktion. Eine ausgefeilte Konstruktion kann sich der Programmierer zwar trotzdem ausdenken und bauen, diese wird aber nie mit Energie versorgt werden.

Die “main”-Methode ist technisch gesehen eine Methode bzw. eine Schachtel wie jede andere auch. Sie nimmt in Java allerdings eine Sonderfunktion ein, weil eine Methode sofort mit dem roten Knopf verbunden wird, sobald ihr der Programmierer den Namen “main” gibt.

Was passiert mit allen anderen Methoden?

Aufgrund der bisherigen Erklärungen zu den Methoden könnte man denken, dass es überhaupt nur Sinn machen würde, eine “main”-Methode zu schreiben, da nur diese aktiviert werden kann. Das stimmt so nicht ganz. Von der “main”-Methode ausgehend kann man nämlich Verbindungen zu allen anderen Methoden herstellen und diese so mit Energie versorgen. Die Hauptstromleitung kommt von außen zwar nur in die Haupt-Schachtel, diese kann die Energie aber an alle anderen Schachteln weiterleiten.

Zum Schluss folgt hier noch ein Beispiel, wie das “Hallo Welt!”-Beispiel aussehen würde, wenn man eine weitere Methode ergänzen würde. Was wir hier also sehen, sind zwei Methoden-Schachteln, die sich zusammen in der äußeren Schachtel befinden:

1
2
3
4
5
6
7
8

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

Und hier zur Veranschaulichung nur die Methoden-Köpfe:

1
2
3
4
5
6
7
8

______ _____ _________ _
    public static void main(String[] args) _
         _________________________ ________
    _
    public static void beispielFürEineWeitereMethode() _
         _________________________ ____ ___________
    _
_

Zur Wiederholung: Runde Klammern in einem Block-Kopf sind ein Hinweis für eine Methode:

1
2
3
4
5
6
7
8

______ _____ _________ _
    ______ ______ ____ ____(________ ____) _
         _________________________ ________
    _
    ______ ______ ____ _____________________________() _
         _________________________ ____ ___________
    _
_

Fazit

In diesem Artikel haben wir die erste Block-Art kennen gelernt, den Methoden-Block. Man erkennt Methoden-Blöcke u. a. an den runden Klammern im Kopf, der Name einer Methode steht unmittelbar vor diesen Klammern. Es gibt eine besondere Methode, diese trägt den Namen “main”. Die “main”-Methode wird aktiviert, wenn der Benutzer am Zaun auf den roten Knopf drückt.

In unserem “Hallo Welt!”-Beispiel-Code sind es zwei an der Zahl. Der eine Block befindet sich innerhalb des anderen Blocks:

1
2
3
4
5

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

Kopf und Körper

Ein Code-Block besteht immer aus zwei Teilen, die man Kopf und Körper nennt. Bei einer Schachtel würde man hier von Deckel (Kopf) und der eigentlichen Schachtel (Körper) sprechen. Wo sich genau Kopf und Körper im Code befinden, ist durch die Position der geschweiften Klammern im Quelltext festgelegt und eindeutig zu erkennen. Vereinfacht kann man sagen: Der Kopf eines Blocks (der Deckel der Schachtel) ist der Text, der vor der geöffneten, geschweiften Klammer steht. Der Körper des Blocks (Schachtel selbst) ist das, was sich innerhalb der geschweiften Klammern befindet.

Anhand des “Hallo Welt!”-Quellcodes kriegen wir das ganz einfach raus. Hier noch einmal der Übersichtlichkeit wegen die ausgeblendete Version:

1
2
3
4
5

______ _____ _________ {
    ______ ______ ____ _____________ _____ {
         _________________________ ________
    }
}

Also, wir haben hier zwei ineinander geschachtelte Code-Blöcke. Es folgt eine Veranschaulichung, was in diesem unseren Beispiel der Kopf und der Körper des äußeren Blocks ist. Den Kopf werde ich mit “1″ markieren, den Körper mit “2″.

1
2
3
4
5

111111 11111 111111111 {
    222222 222222 2222 2222222222222 22222 2
         2222222222222222222222222 22222222
    2
}

Sehen wir uns das einmal ganz genau an: Alles vor der äußeren, geöffneten, geschweiften Klammer ist der Kopf des Blocks. Alles, und zwar wirklich alles, innerhalb der geschweiften Klammern bildet den Körper des Blocks. Dazu gehören auch alle auftretenden inneren geschweiften Klammern, eben einfach alles.

Als zweite Veranschaulichung möchte ich zeigen, wo sich Kopf und Körper des inneren Blocks befinden (wieder mit “1″ und “2″ markiert):

1
2
3
4
5

______ _____ _________ {
    111111 111111 1111 1111111111111 11111 {
         2222222222222222222222222 22222222
    }
}

Auch das sehen wir uns einmal ganz genau an, wir beginnen diesmal mit dem Körper: Dieser schließt wieder alles ein, und zwar wirklich alles, was sich innerhalb der geschweiften Klammern befindet. Der Kopf allerdings schließt hier nicht auch noch die erste Code-Zeile komplett mit ein, obwohl sich diese ja streng betrachtet auch “vor” der inneren, geöffneten, geschweiften Klammer befindet (wir wissen: Zeilenumbrüche spielen keine Rolle). Also in etwa so:

1
2
3
4
5

111111 11111 111111111 1
    111111 111111 1111 1111111111111 11111 {
         2222222222222222222222222 22222222
    }
}

Dies ist aber nicht der Fall. Und der Grund dafür ist auch einleuchtend: Die erste Zeile gehört ja bereits zum äußeren Block, also zur äußeren Schachtel. Und der gleiche Block-Kopf kann nicht gleichzeitig sowohl zum inneren als auch zum äußeren Block gehören, genau so wie der Deckel einer inneren Schachtel ja auch nicht gleichzeitig auf einer äußeren Schachtel sitzen kann. Das wäre unlogisch.

Wozu die Schachteln?

Jetzt haben wir erfahren, wie man die Blöcke im Quelltext erkennen kann. Aber wir wissen noch nicht, wozu wir sie eigentlich brauchen. Eine einfache Erklärung ist schnell gegeben: Wie Schachteln im wirklichen Leben verwenden wir die Blöcke in Java zu dem Zweck, Dinge, die zusammen gehören, auch an der gleichen Stelle aufzubewahren. Dazu ist der Körper eines Blocks da: Wenn Dinge etwas miteinander zu tun haben, werden wir sie später auch in den gleichen Block-Körper stecken. Der Block-Kopf steht sinnbildlich für den Deckel einer Schachtel. Und für diesen Zweck werden wir auch den Block-Kopf in Java verwenden: um genauer zu beschreiben, was sich in der betreffenden Schachtel eigentlich befindet und was man damit machen kann.

Einrückung

Nun, da klar ist, wo an einem Block der Kopf und wo der Körper ist, kann auch geklärt werden, warum in unserem fünfzeiligen “Hallo Welt!”-Beispiel die Zeilen 2, 3 und 4 nicht ganz vorne beginnen, sondern hier am Anfang ein paar Leerzeichen eingefügt wurden. Der Übersetzer “javac” ignoriert bekanntermaßen alle überflüssigen Leerzeichen und Zeilenumbrüche. Das bedeutet, wir als Programmierer können diese setzen, wo es uns gefällt. Und das tun wir auch. Wir setzen Leerzeichen und Zeilenumbrüche so, dass es der Übersichtlichkeit, der besseren Lesbarkeit des Quelltextes dient.

Es hat sich unter Java-Programmierern eingebürgert, dass man den gesamten Block-Kopf zusammen mit der geöffneten, geschweiften Klammer, die den Block-Körper einleitet, in eine einzige Zeile schreibt (was man ja nicht müsste). Alle folgenden Zeilen werden ein paar Leerzeichen eingerückt, und zwar so lange, bis der Quelltext an der geschlossenen, geschweiften Klammer des jeweiligen Blocks angelangt ist. Diese schließende Klammer steht wieder an der ursprünglichen Position.

Zeile 3 ist deshalb “doppelt” weit eingerückt, weil sich diese sowohl innerhalb des inneren, als auch innerhalb des äußeren Blocks befindet.

Füße

Ergänzend zum Kopf und Körper eines Blocks sei an dieser Stelle erwähnt, dass ein Block auch noch einen Fuß haben kann. Der Fuß eines Blocks wird der Bereich im Quelltext genannt, der sich nach der geschlossenen, geschweiften Klammer befindet (und, wie beim Kopf auch, nicht bereits zum äußeren Block gehört). Block-Füße brauchen wir zwar erst etwas später, das Prinzip wollte ich aber an dieser Stelle der Vollständigkeit zuliebe schon erklären.

Fazit

Wir haben in diesem Artikel gesehen, dass ein Block jeweils aus einem Kopf und einem Körper besteht. Optional kann ein Block auch einen Fuß haben. Im Körper eines Blocks können sich beliebig viele “Unter”-Blöcke befinden. Diese “Unter”-Blöcke werden durch Leerzeichen eingerückt, damit man sie besser als solche erkennen kann. Blöcke sind dazu gedacht, um thematisch Gleiches zusammen zu halten.

Blöcke

Lesen wir das “Hallo Welt!”-Programm einmal wie die Seite eines Buches von oben nach unten und von links nach rechts. Zuerst kommen hier die Wörter “public”, “class” und “HalloWelt”. Diese wollen wir vorerst überlesen. Dann taucht im Quelltext die erste geöffnete, geschweifte Klammer “{” auf, und zwar am Ende von Zeile 1.

1
2
3
4
5

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

Außer dieser geschweiften Klammer am Ende von Zeile 1 gibt es noch mehr geschweifte Klammern im Quelltext. Betrachten wir zunächst also alle geschweiften Klammern. Die Nächste finden wir am Ende von Zeile 2. Die dritte Zeile ist in dieser Hinsicht uninteressant, da gibt es nur runde und eckige Klammern. Dafür finden wir in Zeile 4 und Zeile 5 jeweils eine geschlossene, geschweifte Klammer vor “}”.

Zum besseren Verständnis blenden wir hier einmal alles andere aus:

1
2
3
4
5

______ _____ _________ {
    ______ ______ ____ _____________ _____ {
         _________________________ ________
    }
}

Folgendes fällt auf: Es sind genau so viel offene wie geschlossene, geschweifte Klammern vorhanden, nämlich jeweils 2. Die geschweiften Klammern sind ineinander geschachtelt. Wenn wir kurz den restlichen Text, und auch noch die Zeilennummern vergessen, dann sieht es folgendermaßen aus:

 { {  } }

Schachtelung bedeutet hier, dass die beiden inneren Klammern (Klammer 2 und Klammer 3) und die beiden äußeren Klammern (Klammer 1 und Klammer 4) zusammen gehören. Man könnte sagen, die inneren Klammern stellen eine kleine Schachtel dar, die sich in einer größeren Schachtel, nämlich den äußeren Klammern, befindet. Anders als in unserem “Hallo Welt!”-Beispiel können sich auch noch mehr als eine Schachtel in einer größeren Schachtel befinden, und die Schachtelung ist theoretisch auch beliebig “tief” möglich. Es ist also folgendes durchaus denkbar:

 { {  } { {  } } {  } }

Solche Fälle kommen in der Praxis auch tatsächlich vor, jetzt am Anfang aber noch nicht.

Den Bereich von einer zusammengehörigen, geöffneten, geschweiften Klammer bis zu einer geschlossenen, geschweiften Klammer nennt man “Block”, oder auch “Code-Block”. Wie wir gesehen haben gibt es “Blöcke innerhalb von Blöcken”, so wie es “Schachteln innerhalb von Schachteln” gibt. Im Folgenden erfahren wir noch mehr über Blöcke im Quelltext.

Ist die Wiese noch grün?

Der Vergleich mit der grünen Wiese ist an dieser Stelle nach wie vor noch denkbar, wenn man sich vorstellen möchte, dass wir die Schachteln (Blöcke) eben auf dieser Wiese platzieren. Es ist dann eben ein wenig Fantasie gefragt, wenn wir die fünfte Schachtel innerhalb einer Schachtel innerhalb einer Schachtel einfügen, und darin dann auch noch ausgefeilte Konstruktionen Platz finden müssen.
Mit der grünen Wiese und dem Zaun wollte ich vor Allem die Beziehung zwischen Programmierer, Programm und Benutzer verdeutlichen. Jetzt tauchen wir langsam tiefer in die Java-Programmierung und den Code ein und ich werde nicht mehr jedes Detail anhand der grünen Wiese erklären. Trotzdem wird der Vergleich hin und wieder auftauchen und darf selbstverständlich immer als Gedankenstütze hergekommen werden.

Der Quellcode, die Blöcke und die Zeilen

Um zu verstehen, warum es Blöcke im Quelltext gibt, muss man wissen, dass es bei Java nicht drauf ankommt, in welcher Zeile welcher Befehl geschrieben steht und an welcher Stelle innerhalb einer Zeile. In der Tat ist das völlig egal. Aber es ist ganz und gar nicht egal, in welcher Reihenfolge die Befehle stehen.

Um das zu verdeutlichen, folgt ein Beispiel für das “Hallo Welt!”-Programm, das exakt gleich wie die schon mehrmals gezeigte Variante funktioniert:

1
2
3
4
5
6
7
8
9
10
11

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

Auch folgender Quelltext hat genau die selbe Bedeutung:

1

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

Wie wir sehen, kann der Quelltext des “Hallo Welt!”-Programms in fünf Zeilen, aber auch in 11 oder auch nur in einer Zeile stehen. Wir können alle drei gezeigten Versionen mit “javac” übersetzen und wir werden jedes mal das gleiche Ergebnis erhalten, nämlich ein Programm, das “Hallo Welt!” in die Kommandozeile schreibt.

Woran liegt es, dass die drei Quelltexte, die auf den ersten Blick so unterschiedlich aussehen, das gleiche Ergebnis liefern? Dem genauen Beobachter ist vielleicht aufgefallen, dass sich die Reihenfolge der Wörter und Zeichen über die drei Varianten hinweg nicht verändert hat. Lediglich die Zeilenumbrüche wurden verändert, und auch wurden Leerzeichen vor und zwischen den einzelnen Wörtern eingefügt oder gelöscht. Da diese Tatsache für das übersetzte und gestartete Programm aber offensichtlich keine Rolle spielt, muss das bedeuten, dass sich der Übersetzer “javac” überhaupt nicht für Zeilenumbrüche interessiert. Auch die Position der Befehle in einer Zeile, die wir als Programmierer z. B. mit Leerzeichen bestimmen können, werden von “javac” komplett ignoriert.

Lediglich ganz bestimmte Leerzeichen dürfen nicht entfernt werden, und zwar dann, wenn dadurch andere Wörter entstehen würden. Als Beispiel nehmen wir dafür die erste Zeile aus unserem ursprünglichen “Hallo Welt!”-Quelltext:

Das Orginal:

public class HalloWelt {

Folgendes darf man machen:

public           class HalloWelt {

Aber das ist nicht zulässig:

publicclass HalloWelt {

Wir haben die Java-Wörter “public” und “class” zwar noch nicht behandelt, aber ich kann an dieser Stelle schon einmal vorweg nehmen, dass diese beiden Wörter in der Tat zur Java-Sprache gehören. Ein Wort wie “publicclass” allerdings nicht.

Zusammengefasst kann man sagen, dass der Programmierer (mit der soeben genannten Einschränkung) im Quelltext Zeilenumbrüche und Leerzeichen einfügen und löschen kann, wie es ihm beliebt. Sehen wir uns dazu noch einmal die Zeile 3 aus unserem ursprünglichen “Hallo Welt!”-Quelltext an:

System.out.println("Hallo Welt!");

Dieser Ausschnitt aus dem Quelltext taucht sowohl in unserer 5-zeiligen, als auch in der 11-zeiligen und der einzeiligen Quelltext-Variante auf. Und dieses Stück Quelltext befindet sich in jeder Variante immer innerhalb des inneren, geschweiften Klammer-Blocks, sozusagen innerhalb der innersten der beiden Schachteln, auch wenn diese jedes mal in unterschiedlichen Zeilen stehen. Und nur darauf kommt es an: Java-Code wird durch Klammersetzung strukturiert, nicht durch Zeilenumbrüche oder Leerzeichen.

Fazit

Wir haben in diesem Artikel die grobe Struktur von Java-Quellcode betrachtet. Java-Code ist in Blöcken strukturiert, die mit geschweiften Klammern erstellt werden.

In vielen Produkt-Bescheibungen kann man lesen, dass das Gerät unter Android funktionieren soll, Benutzerbewertungen erzählen da teilweise wieder etwas anderes. So ging das Gerät bei mir anfangs auch nicht, zumal die mitgelieferte PDF-Bedienungsanleitung lückenhaft ist. Im Android Market gibt z. T. kostenpflichtige Software, die noch Abhilfe schaffen soll, bei mir hat keine dieser Apps funktioniert. Dieser Artikel beschreibt, wie ich es dann doch noch geschafft habe.

ACHTUNG! In diesem Artikel beschreibe ich, wie es BEI MIR funktioniert hat. Ich weise hier ausdrücklich darauf hin, dass ich keinerlei Verantwortung übernehme, falls etwas bei Eurem Telefon nicht funktionieren sollte!

1. Bluetooth Scan und Pairing

Am Rand der Bluetooth-Tastatur gibt es einen Ein-/Aus-Schalter. Schaltet das Gerät dort ein (natürlich erst nach vorherigem Aufladen am mitgelieferten USB-Kabel). Eine blaue LED leuchtet dann für ca. 2 Sekunden auf und geht dann wieder aus, das ist normal.

Evtl. kann das Android-Telefon die Tastatur jetzt schon sehen. Geht dazu nach

Einstellungen -> Drahtlos & Netzwerke -> Bluetooth Einstellungen

und klickt auf “Scan nach Geräten”. Falls die Tastatur jetzt noch nicht auftauchen sollte, muss auf der Tastatur auf den “Pairing”-Knopf gedrückt werden. Diesen habe ich zunächst übersehen, da er etwas unscheinbar angebracht ist. Und zwar befindet sich dieser Knopf auf der Tastatur-Vorderseite rechts neben den LEDs und ist nur mit dem Fingernagel gut zu drücken. Nach Betätigung des Knopfes müsste eine LED zu Blinken beginnen, die Tastatur ist nun im Pairing-Modus und müsste spätestens jetzt nach einem weiteren “Scan nach Geräten” am Android-Telefon in der Liste auftauchen.

Es folgt nun das erste kleine Hindernis, das in der Bedienungsanleitung der Tastatur mit keinem Sterbenswörtchen gewürdigt wurde. Klickt man nun am Smartphone auf “Pairing mit diesem Gerät”, erscheint ein Dialog, wo man einen Pairing-Code eingeben muss. Dieser Code ist völlig beliebig, ich wähle immer

1111

und zwar aus folgendem Grund: Exakt der gleiche Code muss nun auf der Bluetooth-Tastatur im Pairing-Modus eingegeben werden, gefolgt von einem Tastendruck auf ENTER. Die Einsen lassen sich auf der Tastatur leicht drücken, da sich die “1″ links oben in der Ecke befindet. Ist dieser Vorgang abgeschlossen, erscheint in der Liste der Bluetooth-Geräte auf dem Smartphone nicht mehr “Pairing mit diesem Gerät”, sondern ein anderer Text, bei mir “Gepaart, aber nicht verbunden”. Erscheint bei Euch ein anderer Text (“Verbindung hergestellt” o. ä.), dann habt Ihr Glück und müsst nicht weiterlesen. Leider war das bei mir nicht der Fall.

2. root

Nachdem ich alle Bluetooth-Tastatur-Apps aus dem Market ausprobiert hatte, für die man kein root braucht, war ich soweit, dass ich mein Phone doch “rooten” wollte. “Root” bedeutet, dass man sein Telefon (bzw. bestimmte Apps) in einen Betriebs-Modus versetzt, in dem sie die volle Kontrolle über das gesamte Betriebs-System des Smartphones haben, was normalerweise nicht der Fall ist. Hinter den vielfältigen Möglichkeiten, die Apps damit nun haben können, verbergen sich natürlich auch die Risiken, das System irreversibel zu Beschädigen. Abgesehen davon ist der Vorgang des “rootens” ein Risiko an sich, falls im “worst case” das Telefon danach nicht mehr funktioniert, mal ganz abgesehen vom Aufgeben der Garantieansprüche des Smartphones.

Um es kurz zu machen: Ich habe mein Telefon nach dieser Anleitung erfolgreich gerootet, allerdings mit einer neueren Version der root-Software “SuperOneClick” und zwar “v2.3.3″. Beim ersten root-Version tat sich nichts, evtl. gab es ein Problem mit der USB-Verbindung zum PC, es war hinterher aber auch nichts kaputt. Der zweite Durchlauf verlief dann problemlos und ich hatte “root” auf meinem Telefon.

Problem: Auch die Bluetooth-Apps, die nur mit “root” funktionierten, brachten meine Tastatur nicht zum Laufen.

3. custom rom

Nach einigem Weiter-Recherchieren kam heraus, dass die Bluetooth-Tastatur ein HID-Gerät ist. Damit ist das Verbindungs-Protokoll zwischen Tastatur und Telefon gemeint. In meiner doch recht aktuellen Android-Version von 2.3.5, sollten die zuständigen HID-Treiber eigentlich vorhanden sein, also hätte es funktionieren müssen. Da die Firmware auf meinem Telefon aber nicht das Original von Google, sondern eine eigene Anpassung von LG ist, gehe ich inzwischen davon aus, dass die HID-Treiber von LG entfernt wurden, ob versehentlich oder absichtlich spielt jetzt auch schon keine Rolle mehr.

Lösung: Ein so genanntes “custom rom”. D. h. man ersetzt das aktuelle Betriebs-System auf dem Telefon durch eine andere Version. Ich habe mich an dieser Stelle für “Cyanogen” entschieden. Die Version 7 dieses alternativen Android-Betriebssystems ist leider noch nicht fertig gestellt und ausgereift. Funktionieren tut sie trotzdem. In diesem Thread steht alles, was man dazu braucht (Achtung: die neuesten Downloads stehen immer ganz am Ende des Threads und nicht auf der ersten Seite, wo auch die Installations-Anleitung zu finden ist).

Nach der Installation von “Cyanogen” wiederholte ich einfach Punkt 1 dieses Artikels und meine Bluetooth-Tastatur funktionierte sofort einwandfrei und ohne die Installation weiterer Apps.

4. Fazit

Es ist wahrscheinlich etwas Glücksache, ob HID-Treiber auf dem Andriod-Telefon vorhanden sind, das man gerade in der Hand hält, denn davon hängt wohl das Funktionieren der Tastatur ab. Ich bin inzwischen sehr zufrieden mit “Cyanogen”, das im Übrigen viel schneller läuft als meine vorherige Android-Variante. Lediglich der Akku-Verbrauch hat sich zum Negativen verändert. Aber ich bin zuversichtlich, dass sich dies noch verbessern wird. Schließlich ist die Version, die ich gerade auf dem Telefon habe, noch nicht mal eine Beta-Version.

Der Code

Den Text bestehend aus Java-Befehlen, den man in eine .java-Datei schreibt, und der später übersetzt wird, wie wir das schon selbst gemacht haben, nennt man “Quelltext”. Quell deshalb, weil dieser Text die Quelle des späteren Programms ist. Ohne Java-Befehle würde es kein Programm geben, das ein Benutzer verwenden könnte. Synonyme für “Quelltext” sind “Quellcode” (englisch “source code”) oder oft auch einfach nur mit “Code” abgekürzt. Deshalb wird programmieren manchmal auch als kodieren (englisch “coding”) bezeichnet.

Ist Java englisch?

Sehen wir uns, bevor wir richtig einsteigen, noch einmal kurz den Code zum “Hallo Welt!”-Programm an:

1
2
3
4
5

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

Dieser Code besteht aus 5 Zeilen. Man erkennt durchaus einzelne Wörter, z. B. “public”, “class”, “static”, woraus man schließen könnte, dass Java irgendwie mit englisch verwandt ist. Aber auch unser “Hallo Welt!” sehen wir hier in Zeile 3. Ein Mix aus deutsch und englisch also? Nicht ganz. Offensichtlich liest sich Java überhaupt nicht wie eine Sprache für Menschen (deutsch oder englisch). Die geschweiften, runden und eckigen Klammern und Satzzeichen (“.”, “;”), die man beim genaueren Hinsehen erkennt, und die fehlende deutsche oder englische Grammatik lassen den Text sehr technisch aussehen. Trotzdem stimmt es, dass Java einige englische Wörter enthält. Auf Englisch hat man sich schon sehr früh in der Geschichte der Programmiersprachen geeinigt, und heutzutage ist Englisch aus der Computer-Welt überhaupt nicht mehr wegzudenken. Nahezu alle Programmiersprachen haben sich aus dem englischen Wortschatz bedient. Die Grammatik allerdings, also der Aufbau der einzelnen Wörter, der das formt, was man hier oben als “Hallo-Welt!”-Code lesen kann, ist nicht aus dem Englischen und auch sonst aus keiner Menschen-Sprache übernommen, sondern folgt ganz eigenen Regeln.

Wie das deutsche “Hallo Welt!” in dieses Gefüge passt, darauf werden wir später noch zurück kommen. Es sei hier aber auf jeden Fall erwähnt, dass dieses kurze Stück “deutsch” keinen logischen Bruch zum soeben Erklärten darstellt, das hat eine einfache und einleuchtende Erklärung.

In Farbe, und bunt!

Der Quelltext wird hier in verschiedenen Farben und Schrift-Formatierungen (manchmal fett, manchmal normal) dargestellt. In vielen (wenn auch nicht in allen) hier für den Beginn vorgeschlagenen Editoren, wird der Quelltext allerdings einfarbig und unformatiert angezeigt. Die Farben dienen lediglich der besseren Lesbarkeit und haben keinerlei Einfluss bzw. Bedeutung für den Quelltext. Diese Einfärbung und Formatierung, die meistens automatisch, also ohne Zutun des Programmierers geschieht, werden wir auch noch später behandeln. Zum jetzigen Zeitpunkt soll uns das aber nicht weiter stören und wir tun so, als wäre der Quelltext einfarbung und unformatiert.

Fazit

Wir haben gelernt, dass man den Java-Text, mit dem wir uns im Folgenden hauptsächlich beschäftigen werden, auch “Quelltext”, “Quellcode” oder “Code” genannt wird, und dass dieser “Code” hauptsächlich aus englischen Wörtern und sonstigen Zeichen wie verschiedene Arten von Klammern und Satzzeichen besteht. Textliche Formatierungen und Einfärbungen, wenn Quelltext beispielsweise in einem Editor oder auf einer Internet-Seite zu lesen ist, spielt für die Funktion des Quelltextes überhaupt keine Rolle.

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

d:
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.