Wir erstellen wir eine neue Textdatei mit Notepad. Wir nennen sie HalloWelt.java
Nun geben wir folgendes ein und achten dabei auch auf Groß/Kleinschreibung.
public class HalloWelt
{
public static void main(String[] args)
{
System.out.println("Hallo Welt!");
}
}
nun wechseln wir in die Konsole und wechseln in das Verzeichnis in dem unsere Datei liegt (z.B. C:\Users\USER\Documents\).
dann kommpilieren wir die Datei mit javac HalloWelt.java
Anschließend führen wir sie mit java HalloWelt aus.
Als Ergebnis sollte Hallo Welt! auf dem Bildschirm erscheinen.
Wenden wir uns nun dem Quelltext zu.
public bedeutet das die class öffentlich ist. Wie wir bereits im vorherigen Kapitel kennengelernt haben ist eine class oder Klasse die Beschreibung eines speziellen Datentyps der Objekt genannt wird. Dieser Datentyp enthält Daten beliebiger Art und zugleich kleine Programme, Methoden genannt, die diese Daten manipulieren können. Öffentlich ist sie weil andere Objekte darauf zugreifen können. Bei großen Programmen ist das später wichtig und dient der Ordnung und Übersichtlichkeit.
public static void main(String[] args) ist die Einstiegsmethode also der Punkt an dem gestartet wird. Damit befassen wir uns gleich mehr. System.out.println greift auf eine Methode des Objekts out in der Klasse System zu. Wir erinnern uns, eine Methode ist ein kleines Miniprogramm innerhalb einer Klasse oder einem daraus gebildeten Objekt. Neben der Methode println kann man über System.out auch noch die Methode print ansprechen. Der Unterschied ist hier das println automatisch eine neue Zeile anlegt, print jedoch nicht. Andere Klassen sind für das Lesen von Dateien zuständig oder können Polygone erstellen. Eine komplette Übersicht findet man hier. Zu Beginn fühlt man sich schnell von der großen Anzahl an zur Verfügung stehenden Klassen überfordert. Deswegen verwenden wir Stück für Stück mehr dieser Klassen. Die mitgelieferten Klassen in Java nennt man Klassenbibliothek und ist in Packete unterteilt. java.lang ist praktisch Standard und muss nicht extra eingebunden werden. Zu ihr gehört auch die Klasse System. Alle anderen Klassen müssen mit
import java.paketname.klassenname
eingebunden werden. Wenn man alle Klassen eines Paketes importieren möchte schreibt man hinter den Paketnamen einen Stern:
import Paketname.*
Jetzt beschäftigen wir uns ein wenig genauer mit der Einstiegsmethode. Wir erstellen eine weitere Textdatei mit Notepad. Wir nennen Sie AusgabeString.java
public class AusgabeString
{
public static void main(String[] argumente)
{
System.out.println("Argumente: " + argumente[0] + " " + argumente[1]);
}
}
Wir kompilieren neu und starten wieder, allerdings mit 2 Argumenten.
Wir geben also ein: java AusgabeString argument1 argument2
Es müsste nun Argumente: argument1 Argument2
Experimentieren wir ein wenig damit und geben z.B. ein: java AusgabeString Guten Morgen
Jetzt wissen wir wozu das (String[] argumente) eigentlich da ist. String[] bezeichnet ein Array. Ein Array ist eine Variable die mehrere Variablen enthält. Also praktisch ein Ordner mit beliebig vielen Dateien. Nur das der Ordner hier argumente heisst und die Variablen in diesem Ordner keine eigene Namen besitzen sondern durchnumeriert sind. Hierbei ist zu beachten, das die Numerierung immer mit 0 beginnt. Das erste Feld kann durch argumente[0] angesprochen werden, das zweite durch argumente[1] usw.
Wir können also noch mehr Argumente angeben. Nur müssen wir dafür sorgen daß das entsprechende Feld auch gelesen wird:
System.out.println("Argumente: " + argumente[0] + " " + argumente[1] +" " + argumente[2]);
Ein String ist immer eine Zeichenkette beliebiger Zeichen und Ziffern. Wir können auch selbst String Variablen anlegen. Dies machen wir zum Beispiel mit:
String ersterString = "Dies ist ein String";
Diese Vorgehensweise ist bei allen Variablen dieselbe. Zuerst gibt man den Typ an gefolgt von einem Namen der anschließend optional ein Wert der zugewiesen werden kann. Wird der Wert weggelassen spricht man nur von einer Deklaration. Wird ein Wert zugewiesen wird die Variable auch noch initialisiert.
Typ name; // Deklaration
Typ name = Wert; // Initialisierung
Wenn wir ein Array anlegen wollen schreiben wir einfach hinter der Typbezeichnung ein [] also beispielsweise:
String[] x;
Um Daten in diesen String einzufügen verwendet man einen Anweisungsblock, gekennzeichnet durch die geschwungenen Klammern {} und trennt die einzelnen Strings durch Kommata. z.B.:
String[] x = {"Hallo", "Welt", "Ein weiterer String", "John Smith"}
System.out.println(x[0] + " " + x[3]); // gibt „Hallo John Smith“ aus.
Nun wollen wir ein Fenster öffnen. Legen wir eine neue Datei mit Namen erstesFenster.java an und geben folgenden Code ein:
import javax.swing.JFrame;
public class ErstesFenster extends JFrame {
public static void main(String[] args) {
ErstesFenster fenster = new ErstesFenster();
fenster.setVisible( true ); // macht das Fenster sichtbar
fenster.setBounds( 0, 0, 900, 500 ); // legt die Größe fest (x,y,Breite,Höhe)
fenster.setAlwaysOnTop( true ); // sorgt dafür das es immer im Vordergrund bleibt
fenster.setDefaultCloseOperation( EXIT_ON_CLOSE );//legt fest was nach dem Schließen passiert
fenster.setLocationRelativeTo( null ); // zentriert das Fenster in der Mitte des Bildschirms
}
}
extends JFrame erweitert die class Fenster um die Klasse JFrame die ein Standard Fenster beinhaltet. Dadurch erhalten alle Objekte die wir aus unserer Klasse bilden die Methoden der Klasse JFrame. Theoretisch benötigt man nach der Objekterstellung nur die Methode setVisible um das Fenster erscheinen zu lassen. Allerdings bestünde es dann nur aus der oberen Leiste und wäre sehr klein. Die Befehle sind überwiegend selbsterklärend. setDefaultCloseOperation legt fest was nach dem Schließen passiert. Wenn ihr diesen Befehl rausnehmt, wird das Fenster zwar geschlossen, das Programm im Speicher aber nicht beendet und belegt weiterhin Speicherplatz. Deshalb sollte immer festgelegt werden was nach dem Schließen passiert. In diesem Fall wird das Programm beendet.
Nun wollen wir etwas rechnen. Wir erstellen eine neue Datei und nennen sie: Addiere.java
Nun geben wir folgendes ein:
public class Addiere
{
public static void main(String[] argumente)
{
System.out.println("Argumente: " + argumente[0] + " " + argumente[1]);
int wert1 = Integer.parseInt(argumente[0]);
int wert2 = Integer.parseInt(argumente[1]);
int ergebnis = wert1 + wert2;
System.out.println("Ergebnis der Addition: " + ergebnis);
}
}
wir kompilieren wieder die Datei mit javac Addiere.java und geben danach ein:
java addiere 10 20
Jetzt wissen wir wozu das (String[] argumente) eigentlich da ist. String[] bezeichnet ein Array. Ein Array ist eine Variable die mehrere Variablen enthält. Also praktisch ein Ordner der Variable enthält. Nur das der Ordner hier argumente heisst und die Variablen diesem Ordner keine eigene Namen besitzen sondern durchnumeriert sind. Hierbei ist zu beachten, das die Numerierung immer mit 0 beginnt. Das erste Feld kann durch argumente[0] angesprochen werden, das zweite durch argumente[1] usw.
Da die übergebenen Daten vom Typ String sind, müssen wir sie, um damit rechnen zu können erst in Zahlen konvertieren. Das geschieht mit Integer.parseInt(argumente[0]); Die Klasse Integer ist fester Bestandteil von Java. Jeder Typ in Java hat eine Vielzahl von Standardmethoden mit denen er manipuliert oder eben konvertiert werden kann. Diese Typen werden auch primitive Datentypen genannt. Hier eine Übersicht
Die eigentliche Rechnung ist denkbar einfach: int ergebnis = wert1 + wert2;
Die häufigste Datentyp-Art die anzutreffen ist, ist Integer. Mit Integer und String werden wir auch am häufigsten arbeiten. Modifizieren wir nun das Programm noch etwas:
public class Addiere
{
public static void main(String[] argumente)
{
for(int i=0;i<argumente.length;i++)
System.out.println("Argument: " + argumente[i]);
int wert1 = Integer.parseInt(argumente[0]);
int wert2 = Integer.parseInt(argumente[1]);
int ergebnis = wert1 + wert2;
System.out.println("Ergebnis der Addition: " + ergebnis);
}
}
for(int i=0;i<argumente.length;i++) ist eine for-Schleife. Normalerweise setzt man danach einen Anweisungsblock mit den geschwungenen Klammern {...} Wenn aber die for-Schleife nur eine einzige Anweisung hat, kann man diese Klammern auch weglassen. Die Definition einer solchen Schleife ist folgendermaßen:
for(zählername; Bedingung; Zählerschritte)
Die Zählerschritte nennt man auch Inkrement/Dekrement. Inkrement bezeichnet die Erhöhung des Zählers, Dekrement das Herabzählen des Zählers. Das Array Argumente hat, wenn wir z.B. drei Angaben gemacht haben, die Länge 3. Die Länge kann mit arrayname.length abgefragt werden.
Wir definieren also die Variable i als Integer und weisen ihr den Wert 0 zu. Da wir als Bedingung für die Ausführung der Schleife angeben das i kleiner als die Länge des Array sein muss, greift das Inkrement i++ sobald die Schleife einmal durchlaufen wurde. Dies bedeutet das i um eins erhöht wird. Wir könnten statt i++ auch i = i+1 schreiben.
Da wir bei argumente[i] statt einer Zahl die Variable i eingefügt haben gibt System.out im ersten Durchgang nun das argument[0] aus. Danach wird 0 um eins erhöht und die zweite Runde beginnt. Da ein Array immer mit 0 beginnt, wäre bei drei eingegebenen Argumenten beim Zählerstand 2 Schluss.
Beachten wir auch das eine Variable immer zuerst initialisiert werden muss, bevor sie verwendet werden kann. for(i=0 würde nicht funktionieren, da der Compiler nicht weiss ob er darin Strings oder Zahlen speichern soll. Daher muss es for(int i=0 heissen.
Als nächstes wollen wir ein Fenster erstellen und ein einfaches „Hallo Welt“ dort ausgeben.