Java-Crashkurs

Java ist eine objektorientierte Programmiersprache und Marke von Sun Microsystems, die erstmals 1995 veröffentlicht wurde. Die Programmiersprache Java ist, neben der JDK (Java Development Kit, Entwicklungswerkzeuge zur Programmerstellung) und JRE (Java Runtime Environment, Laufzeitumgebung zur Programmausführung), eines der wichtigsten Bestandteile der Java-Technologie. Java-Applikationen werden im Regelfall als .jar Dateien verbreitet. Dies sind Java-Archive, in welchen Java-Klassen etc. (als kompilierter Java-Bytecode) und Ressourcen enthalten sind.

In diesem Crashkurs werden die Sprachelemente sowie einige wichtige Funktionen der Programmiersprache Java, kurz und mit vielen Beispielen, erklärt. Dieser Crashkurs ist nicht mit einem ausführlichen Java-Tutorial zu verwechseln, sondern dient hauptsächlich zur Auffrischung der Java-Kenntnisse.

Syntax

Der Syntax von Java ähnelt sehr stark dem von C++ und C#. In Java gibt es, wie in den meisten imperativen Programmiersprachen, Anweisungen. Diese müssen mit einem Semikolon abgeschlossen werden. Zur Gruppierung von mehreren Anweisungen werden sogenannte Anweisungsblöcke verwendet. Anweisungsblöcke zeichnen sich durch geschweifte Klammern aus. An einigen Stellen (z. B. bei Abfragen oder Schleifen) können die geschweiften Klammern weggelassen werden, wenn sich innerhalb des Anweisungsblocks nur eine Anweisung befindet. Es gibt jedoch auch andere Stellen (z. B. Funktionen oder Klassen), bei welchen die geschweiften Klammern in keinem Fall weggelassen werden dürfen.

Für Ausgaben auf der Konsole können Sie in Java die Funktionen System.out.print() und System.out.println() (Ausgabe mit anschließendem Zeilenumbruch) verwenden.

Variablen und Datentypen

Variablen sind immer an einen Datentyp gebunden, d. h. der Datentyp muss bei der Deklaration einer Variablen feststehen. Eine Variablendeklaration setzt sich aus dem Datentyp und einem frei definierbaren Namen zusammen. Der Name muss dabei innerhalb des Gültigkeitsbereichs eindeutig sein und darf sich nicht mit reservierten Namen oder anderen Komponenten wie z. B. Klassennamen überschneiden. Das folgende Beispiel zeigt wie eine Variable in Java deklariert wird:

int meineVariable;

Um die Lesbarkeit des Quellcodes zu verbessern, empfiehlt es sich, einen Datentyppräfix (z. B. i beim Datentyp int) zu verwenden:

int iMeineVariable;

Die Wertzuweisung einer Variablen erfolgt mit dem Gleichheitszeichen:

iMeineVariable = 123;

Bei der ersten Zuweisung einer Variablen wird auch von der Variableninitialisierung gesprochen. Bei Bedarf können Sie die Variablendeklaration und -initialisierung auch kombinieren:

int iMeineVariable = 123;

In Java gibt es zwei Gruppen von Datentypen: primitive Datentypen und Objekte. Variablen werden grundsätzlich im Stack-Speicher abgelegt. Da Objekte (und auch Arrays) vom Speicherumfang sehr komplex sein können, werden Objekte auf dem Heap gespeichert. Im Stack befindet sich dann lediglich eine Referenz auf den Heap.

Die folgende Tabelle zeigt, welche primitive Datentypen es in Java gibt:

Datentyp	Wrapper-Klasse	Speicherbedarf	Wertebereich	Beschreibung
boolean	Boolean	1 Bit	true oder false	Wahrheitswert
char	Character	16 Bit	'\u0000' .. '\uFFFF'	Unicode-Zeichen
byte	Byte	8 Bit	-128 .. 127	Ganzzahl
short	Short	16 Bit	-32.768 .. 32.767	Ganzzahl
int	Integer	32 Bit	-2.147.483.648 .. 2.147.483.647	Ganzzahl
long	Long	64 Bit	-9.223.372.036.854.775.808 .. 9.223.372.036.854.775.807	Ganzzahl
float	Float	32 Bit	±1,4E−45 .. ±3,4E+38	Gleitkommazahl
double	Double	64 Bit	±4,9E−324 .. ±1,7E+308	Gleitkommazahl

Wichtig: In Java gibt es keine Datentypen für Ganzzahlen ohne Vorzeichen. Möchten Sie also z. B. Ganzzahlen zwischen 0 und 60.000 speichern, so müssen Sie den Datentyp int verwenden.

Übrigens: Objekte der Wrapper-Klassen werden nur in bestimmen Spezialfällen benötigt. Jedoch enthalten die Wrapper-Klassen auch einige statische Hilfsfunktionen.

Zahlen und Mathematik

Die meisten primitiven Datentypen (ausgenommen sind boolean und char) sind dazu gedacht, Zahlenwerte darzustellen. Die Datentypen float und double sind zur Darstellung von Fließkommazahlen (auch Gleitkommawerte genannt) gedacht, die anderen hingegen für Ganzzahlen.

Die Notation von Zahlen kann in unterschiedlichen Schreibweisen erfolgen. Ganzzahlen werden i. d. R. in der Dezimalschreibweise angegeben. Es ist jedoch auch möglich, diese Zahlen in Binär-, Oktal- oder Hexadezimalschreibweise zu notieren.

dezimal = 123;
binaer = 0b01111011;
oktal = 0173;
hexadezimal = 0x7B;

Wichtig: Ganzzahlen werden standardmäßig als Datentyp int interpretiert. Benötigen Sie eine größere Ganzzahl (und somit den Datentyp long), so kann es in manchen Fällen zu Compilerfehlern führen. Um dieses Problem zu lösen, muss lediglich ein L an den Wert angehängt werden. Ein ähnliches Szenario ist bei Gleitkommazahlen zu finden. Für Gleitkommazahlen wird standardmäßig der Datentyp double verwendet. Möchten Sie jedoch mit float-Werten arbeiten, so sollten Sie dem Wert ein F als Suffix anhängen.

In Java haben Sie, wie in den meisten anderen Skript- und Programmiersprachen auch, die Möglichkeit, Operatoren für die mathematischen Grundrechenarten anzuwenden.

f = (c * 1.8) + 32;

Übrigens: Die verkürzten Schreibweisen wie z. B. a += b an Stelle von der ausgeschriebenen Version a = a + b sind in Java natürlich auch möglich. Eine weitere verkürzte Darstellung ist bei der Addition oder Subtraktion um 1 möglich (also a++ oder a--).

Eine sehr wichtige Klasse für mathematische Funktionen in Java ist Math. Math ist eine Klasse mit statischen Variablen (auch Eigenschaften genannt) sowie einigen statischen Funktionen. Häufig verwendete Funktionen sind unter anderem min() (Minimalwert von zwei Zahlen), max() (Maximalwert von zwei Zahlen), pow() (Potenzrechnung), sqrt() (Quadratwurzel ziehen), floor() (Zahl abrunden), ceil() (Zahl aufrunden), round() (Zahl kaufmännisch runden) und random() (Zufallszahl erzeugen).

minimum = Math.min(a, b);
maximum = Math.max(a, b);
potenz = Math.pow(a, b);

Zeichenketten

Zeichenketten sind eine Aneinanderreihung von einzelnen Zeichen. Ein einzelnes Zeichen können Sie in Java mit Hilfe des Datentyps char darstellen. Ein Zeichen wird dabei in einfachen Anführungszeichen notiert.

char cZeichen = 'A';

Sie könnten nun natürlich, wie es auch in C gemacht wird, ein Array vom Datentyp char definieren, um mehrere zusammengehörende Zeichen zu speichern. Java bietet uns jedoch die Klasse String an, mit welcher es möglich ist, eine Aneinanderreihung von Zeichen einfacher zu speichern. Zeichenketten werden in doppelten Anführungszeichen notiert und werden automatisch als Objekt der String-Klasse gespeichert.

String sZeichenkette = "Hallo! Wie geht’s?";

Mehrere Zeichenketten können über den +-Operator kombiniert werden:

String sBegruessung = "Hallo!";
String sFrage = "Wie geht’s?";
String sZeichenkette = sBegruessung + " " + sFrage;

Die String-Klasse enthält einige Methoden, welche uns beim Verarbeiten einer Zeichenkette helfen. Funktionen, mit welchen Sie die Zeichenkette bzw. dessen Inhalt prüfen können, sind unter anderem isEmpty() (prüft, ob die Zeichenkette leer ist), length() (gibt die Länge der Zeichenkette zurück), charAt() (gibt das Zeichen an der angegebenen Position zurück), indexOf() (gibt den Index des ersten Vorkommens der angegebenen Sequenz zurück), lastIndexOf() (gibt den Index des letzten Vorkommens der angegebenen Sequenz zurück), contains() (prüft, ob die Zeichenkette die angegebene Sequenz enthält), startsWith() (prüft, ob die Zeichenkette mit der angegebenen Sequenz beginnt) und endsWith() (prüft, ob eine Zeichenkette mit der angegebenen Sequenz endet).

String sZeichenkette = "Hallo! Wie geht’s?";
char cErstesZeichen = sZeichenkette.chartAt(0);
int iLaenge = sZeichenkette.length();

Zeichenketten können nicht mehr direkt geändert werden. Alle Methoden der String-Klasse, die zum Bearbeiten einer Zeichenkette genutzt werden können, ändern nicht die Ursprungszeichenkette, sondern erzeugen eine Kopie der Zeichenkette und wenden auf diese die Änderungen an. Folgende Funktionen werden oft verwendet: replace() (ersetzt die angegebene Sequenz durch eine andere), substring() (extrahiert einen Teil der Zeichenkette), toLowerCase() (wandelt alle Buchstaben in Kleinbuchstaben um), toUpperCase() (wandelt alle Buchstaben in Großbuchstaben um) und trim() (entfernt voran- und nachgestellte Leerraumzeichen).

String sZeichenkette = "Hallo! Wie geht’s?";
String sKleineBuchstaben = sZeichenkette.toLowerCase();
String sGrosseBuchstaben = sZeichenkette.toUpperCase();

Eine weitere nützliche Funktion ist split(), welche eine Zeichenkette an einer bestimmten Sequenz trennt und ein Array (dazu später noch mehr) mit den Teilzeichenketten zurückgibt:

String sSatz = "Wie geht es dir heute";
String[] sWoerter = sSatz.split(" ");

Übrigens: Zeichen und Zeichenketten werden in Java mit der Zeichenkodierung UTF-16 gespeichert.

Wichtig: Beim Vergleich von zwei Zeichenketten sollten Sie nicht den Vergleichsoperator == verwenden, sondern die Methode equals(). Ein Vergleich mit dem Vergleichsoperator schlägt i. d. R. fehl, da dadurch nicht der Inhalt der Zeichenkette, sondern die Adresse des Zeichenkettenobjekts verglichen wird.

Arrays und Listen

Ein Array (auch Feld genannt) wird in Java als eigenes Objekt gespeichert. Arrays speichern dabei eine bestimmte Anzahl an Werten eines Datentyps innerhalb einer Variablen. Die Deklaration erfolgt mit eckigen Klammern.

int[] aZahlenliste;

Zu diesem Zeitpunkt ist noch nicht bekannt, wie viele Einträge das Array einmal haben wird. Dies ist aber auch für die Deklaration unerheblich. Möchten Sie nun das Array „erstellen“, so müssen Sie eine Instanz mit dem Schlüsselwort new erzeugen. Auch hier benötigen Sie die eckigen Klammern, in welchen Sie diesmal jedoch die Anzahl der Elemente angeben.

aZahlenliste = new int[10];

Die Deklaration und Instanziierung kann natürlich auch hier wieder kombiniert werden:

int[] aZahlenliste = new int[10];

Möchten Sie die Werte in einem Array bereits vorbelegen, so notieren Sie anschließend einfach ein Paar mit geschweiften Klammern. In dem Klammernpaar können Sie nun die Werte, welche für die Initialisierung verwendet werden sollen, angeben. Die Angabe der Arraygröße fällt in diesem Fall weg.

int[] aZahlenliste = new int[] { 1, 2, 3, 4, 5 };

Dieser Syntax kann bei Bedarf auch noch verkürzt werden:

int[] aZahlenliste = { 1, 2, 3, 4, 5 };

Übrigens: Natürlich können Sie einer Arrayvariablen auch den Rückgabewert einer Funktion zuweisen, falls diese ein Array zurückgibt.

Der Zugriff auf einen Eintrag des Arrays erfolgt nun mit Hilfe eines sogenannten Index. Der Index beginnt bei 0 und endet bei der Anzahl der Elemente minus 1, d. h. der Index ist nullbasierend.

int iErsteZahl = aZahlenliste[0];
int iZweiteZahl = aZahlenliste[1];

Natürlich können Sie den Wert eines Arrayelements auch jeder Zeit ändern:

aZahlenliste[3] = 123;

Möchten Sie die Länge eines Arrays ermitteln (z. B. weil Sie das Array einer anderen Funktion übergeben haben, der die Größe nicht bekannt ist), so können Sie die Eigenschaft length verwenden:

int iLaenge = aZahlenliste.length;

Übrigens: Weitere nützliche Funktionen zum Arbeiten mit Arrays finden Sie in der Klasse Arrays.

Die Größe eines Arrays muss bei der Instanziierung festgelegt werden und kann nicht geändert werden. Benötigen Sie ein dynamisches Array, bei welchem Sie zur Laufzeit Elemente hinzufügen oder löschen können, so können Sie eine Liste verwenden, welche diese Funktionalität bietet. Java bietet uns hier unterschiedliche Listen an. Die gängigste Variante ist jedoch die Klasse ArrayList. Eine ArrayList ist, wie Arrays auch, an einen bestimmten Datentyp gebunden. Dieser wird hier jedoch in eckigen Klammern angegeben (es werden die sogenannten Generics verwendet). Die Instanziierung erfolgt, da es sich um eine ganz normale Klasse handelt, mit dem new-Schlüsselwort:

ArrayList<int> aZahlenliste = new ArrayList<int>();

Um Elemente in die Liste hinzuzufügen wird die Methode add() verwendet. Dieser kann optional ein Index übergeben werden, der angibt, wo das Element eingefügt werden soll. Wird dieser Parameter weggelassen, so wird das Element am Ende hinzugefügt.

aZahlenliste.add(123);
aZahlenliste.add(789);
aZahlenliste.add(1, 456);

Möchten Sie einen Wert von der Liste lesen, so verwenden Sie die Methode get(), welcher Sie den Index übergeben (auch hier ist der Index nullbasierend):

int iMeineZahl = aZahlenliste.get(2);

Das Setzen bzw. Ändern eines Werts erfolgt mit der set()-Methode:

aZahlenliste.set(1, 246);

Möchten Sie einen Wert aus der Liste entfernen, so kann Ihnen die Funktion remove() behilflich sein, welche den Wert am angegebenen Index löscht und zurückgibt:

int iGeloeschteZahl =  aZahlenliste.remove(1);

Eine weitere nützliche Funktion ist clear(), welche sämtliche Elemente der Liste löscht:

aZahlenliste.clear();

Möchten Sie die Länge der Liste ermitteln, so können Sie die Methode size() aufrufen:

int iLaenge = aZahlenliste.size();

Um einen Wert in einer Liste zu suchen, können Sie Funktion indexOf() verwenden. Diese gibt den Index des ersten Elements zurück, welcher mit dem übergebenen Wert übereinstimmt. Wird nichts gefunden, so ist der Rückgabewert -1.

int iSuchIndex = aZahlenliste.indexOf(789);

Bedingungen und Abfragen

Vermutlich eines der wichtigsten Bestandteile eines Programms sind Abfragen (auch Verzweigungen genannt), denn damit ist es möglich, zu prüfen, ob eine Variable einen bestimmten Wert hat, eine Funktion einen bestimmten Wert zurückgegeben hat usw..

Die klassische Abfrage ist die einfache Verzweigung (mit if). Um diese zu verwenden, müssen Sie jedoch erst eine Bedingung aufstellen. Eine Bedingung muss immer einen boolschen Wert (Warheitswert) ergeben. Einen solchen Wahrheitswert können Sie über eine Variable vom Typ boolean oder von einer Funktion mit dem Rückgabetyp boolean erhalten. Einen Wahrheitswert können Sie aber auch mit Hilfe von Vergleichsoperatoren „erzeugen“. Die folgende Tabelle zeigt, welche Vergleichsoperatoren es in Java gibt:

==	ist gleich
!=	ist ungleich
<	ist kleiner
<=	ist kleiner oder gleich
>	ist größer
>=	ist größer oder gleich

Möchten Sie einen Wahrheitswert negieren (also umkehren), so können Sie das Ausrufezeichen ! verwenden. Möchten Sie mehrere Bedingungen kombinieren, so können Sie && (Logische Und-Verknüpfung) und || (Logische Oder-Verknüpfung) verwenden.

Eine einfache Verzweigung besteht aus dem Schlüsselwort if, einer Bedingung (anzugeben in runden Klammern) und einem nachfolgenden Anweisungsblock:

if (a > b)
{
    System.out.println("Zahl a ist größer als b");
}

Möchten Sie zusätzlich den Fall abdecken, falls die Bedingung nicht zutrifft, so können Sie einen else-Block notieren:

if (a > b) 
{
    System.out.println("Zahl a ist größer als b");
}
else
{
    System.out.println("Zahl a ist nicht größer als b");
}

Verzweigungen können natürlich nach Belieben verschaltet werden. Dies kann oft unübersichtlich werden. Deshalb können zwischen if- und else-Block weitere Fälle mit Hilfe von else if-Blöcken geprüft werden.

if (a == b) 
{
    System.out.println("Zahl a ist gleich groß wie Zahl b");
}
else if (a > b) 
{
    System.out.println("Zahl a ist größer als b");
}
else
{
    System.out.println("Zahl a ist kleiner als b");
}

In Java haben Sie aber auch die Möglichkeit, mehrfache Verzweigungen (switch-case) zu verwenden. Der switch-Block definiert dabei den „Auswahlwert“. Die einzelnen case-Blöcke stellen die Vergleichswerte dar und müssen mit einem break-Statement abgeschlossen werden. Bei Bedarf können Sie einen default-Block notieren, um den Fall abzudecken, falls keiner der Fälle zutrifft. Mehrfache Verzweigungen können für Zahlen, Zeichenketten und Enumerationen genutzt werden.

switch (iMultiplikator)
{
    case 1:
        // Weitere Anweisungen ...
        break; 
    case 10:
        // Weitere Anweisungen ...
        break;
    case 100:
        // Weitere Anweisungen ...
        break;
    case 1000:
        // Weitere Anweisungen ...
        break;
    default:
        System.out.println("Ungültiger Multiplikator!");
        break;
}

Sie können case-Blöcke auch stapeln:

case 0:
case 1:
    // Weitere Anweisungen ...
    break;

Schleifen

Um bestimmte Vorgänge mehrmals auszuführen, können Sie Schleifen verwenden. Java bietet uns hier vier unterschiedliche Schleifen an. Die erste und einfachste Schleife ist die while-Schleife. Die while-Schleife ist kopfgesteuert, wobei der Schleifenrumpf solange ausgeführt wird, bis die angegebene Bedingung nicht mehr zutrifft.

int i = 0;
while (i < 10)
{
    System.out.println(i);
    i++;
}

Eine weitere Schleife ist die do-while-Schleife. Bei der do-while-Schleife handelt es sich um eine fußgesteuerte Schleife, d. h. die Bedingung wird erst nach der Ausführung der Anweisungen im Schleifenrumpf geprüft. Eine einmalige Ausführung ist daher garantiert. Das folgende Beispiel würde die gleiche Ausgabe wie das Beispiel zur while-Schleife ausgeben:

int i = 0;
do
{
    System.out.println(i);
    i++;
} while (i < 10);

Im folgenden Beispiel würde aber trotzdem die Zahl 10 ausgegeben werden, da die Bedingung erst am Ende geprüft wird:

int i = 10;
do
{
    System.out.println(i);
    i++;
} while (i < 10);

Das gleiche Beispiel mit einer while-Schleife würde keine Ausgabe erzeugen:

int i = 10;
while (i < 10)
{
    System.out.println(i);
    i++;
}

Die while- und do-while-Schleife wird nur selten für solche Zwecke wie das hier vorgestellte Zählen verwendet. Dies kommt daher, da Java eine weitere Schleife, die for-Schleife, kennt, welche einen ausgeprägten Schleifenkopf hat, der genau für solche Zwecke gedacht ist:

for (int i = 0; i < 10; i++)
{
    System.out.println(i);
}

Der erste Teil des Schleifenkopfs (angegeben in einem runden Klammernpaar) bietet die Möglichkeit, Variablen zu deklarieren oder zu initialisieren. Dieser Teil wird vor der Ausführung der Schleife ausgeführt. Der zweite Teil stellt die eigentliche Bedingung dar, welche vor jeder Ausführung des Schleifenrumpfs geprüft wird. Daher handelt es sich hier ebenfalls um eine kopfgesteuerte Schleife. Der letzte Teil bietet uns die Möglichkeit, eine bestimmte Anweisung auszuführen. Für eine „Zählschleife“ wird hier einfach die Zählvariable inkrementiert.

Eine for-Schleife kann des Weiteren aber auch zur Iteration über Arrays oder Listen genutzt werden. Dies sieht dann z. B. so aus:

int[] iZahlenListe = new int[] { 1, 2, 3, 4, 5};
for (int i : iZahlenListe)
{
    System.out.println(i);
}

Das obige Beispiel wäre äquivalent zu folgender Form:

int[] iZahlenListe = new int[] { 1, 2, 3, 4, 5};
for (int i = 0; i < iZahlenListe.length; i++)
{
    System.out.println(iZahlenListe[i]);
}

Natürlich können Sie das Verhalten von Schleifen auch beeinflussen. Mit Hilfe des Schlüsselworts break können Sie die Schleife beenden. Das continue-Statement kann dazu genutzt werden, erneut zum Schleifenkopf oder auch zum Schleifenfuß zu springen (um dadurch die Bedingung erneut zu prüfen). Im folgenden Beispiel werden die Zahlen 0 bis 7, ausgenommen der Zahl 3, da diese mit continue „übersprungen“ wird, ausgegeben:

for (int i = 0; i < 10; i++)
{
    if (i == 8)
        break;
    if (i == 3)
        continue;
    System.out.println(i);
}

Funktionen

Bisher haben Sie vorhandene Funktionen immer nur genutzt, doch Sie können natürlich auch eigene Funktionen definieren. Beim Aufruf einer Funktion notieren Sie dessen Namen, gefolgt von einem runden Klammernpaar.

System.out.println();

Zwischen den Klammern können Sie dann ggf. (abhängig von der Funktion) ein oder mehrere Argument(e) (auch Parameter oder Übergabeparameter genannt) notieren. Man spricht auch davon, dass man der Funktion Werte übergibt.

System.exit(10);

Einige Funktionen können auch einen Wert zurückgeben. Dieser sogenannte Rückgabewert kann „ignoriert“ oder aber einer Variablen zugewiesen oder in Bedingungen direkt verwendet werden.

int iLaenge = sZeichenkette.length();

Die Deklaration und Definition einer Funktion setzt sich dabei im Allgemeinen aus einem Zugriffsmodifizierer (dazu später noch mehr), einem Rückgabewert, einem Namen und der Parameterliste zusammen. Hat eine Funktion keinen Rückgabewert so wird void angegeben.

public void halloWelt()
{
    System.out.println("Hallo Welt!");
}

Die Funktionsparameter werden in den runden Klammern durch Komma getrennt angegeben. Dazu muss für jeden Parameter ein Datentyp und Name festgelegt werden:

public void addiereZahlen(int a, int b)
{
    System.out.println(a + b);
}

Möchten Sie von der Funktionen einen Wert zurückgeben, so benötigen Sie das Schlüssewort return:

public int addiereZahlen(int a, int b)
{
    return a + b;
}

Übrigens: Das Schlüsselwort return verlässt die Funktion sofort. Bei einer Funktion ohne Rückgabewert können Sie trotzdem jederzeit das return-Statement notieren, um die Funktion zu verlassen.

Des Weiteren ist es möglich, Funktionen zu überladen, d. h. mehrere Funktionen mit dem gleichen Namen zu definieren, die sich von den Parametern unterscheiden:

public int addiereZahlen(int a, int b)
{
    return a + b;
}
public int addiereZahlen(int a, int b, int c)
{
    return a + b + c;
}

In Java gibt es keine Funktionen ohne eine Klasse. Es ist jedoch durchaus möglich, bestimmte Funktionen aufzurufen, ohne ein Objekt der jeweiligen Klasse erzeugen zu müssen. Dies ist vor allem für Klassen mit Hilfsfunktionen (wie z. B. die Arrays-Klasse) nützlich. Um eine solche Funktion (auch als statische Funktion bezeichnet) zu definieren, müssen Sie zwischen Zugriffsmodifizierer und Rückgabetyp das Schlüsselwort static notieren:

public static int addiereZahlen(int a, int b)
{
    return a + b;
}

Übrigens: In Java ist der Haupteinstiegspunkt i. d. R. die main()-Funktion. Auch bei dieser Funktion handelt es sich um eine statische Funktion.

Klassen und Objekte

Als Klasse bezeichnet man vereinfacht gesagt den Bauplan für einen komplexen Datentyp. Ein solcher Datentyp kann dann mehrere Informationen (in Form von Variablen) kapseln. Um den definierten Datentyp zu erzeugen, müssen Sie ein Objekt der Klasse (also des vorliegenden Bauplans) erzeugen. Dies geschieht mit Hilfe des Schlüsselworts new.

Aber erstmal zurück zur Klasse: Eine Klasse wird über einen Zugriffsmodifizierer und das Schlüsselwort class, gefolgt von einem Namen, deklariert:

public class Computer
{
    
}

Innerhalb der Klasse können nun beliebig viele Variablen (auch als Membervariablen oder Eigenschaften bezeichnet) und Funktionen definiert werden. Auch hier muss bei allen Variablen und Funktionen ein Zugriffsmodifzierer angegeben werden. Wird keiner angegeben, so wird automatisch private verwendet:

public class Computer
{
    private int iArbeitsspeicher = 16;
    private double dProzessorTakt = 2.4;
    
    public void printInfo()
    {
        System.out.println("Arbeitsspeicher: " + iArbeitsspeicher + " GB");
        System.out.println("Prozessortakt: " + dProzessorTakt + " GHz");
    }
}

Um von dieser Klasse nun ein Objekt (oftmals auch als Instanz bezeichnet) zu erzeugen, benötigen Sie nun das new-Schlüsselwort:

Computer oMeinComputer = new Computer();

Mit Hilfe des Punktoperators . können Sie nun auf Variablen und Funktionen des Objekts zugreifen:

oMeinComputer.printInfo();

Der Zugriff auf die Variablen im obigen Beispiel würde Ihnen jedoch verwehrt werden. Dies liegt daran, dass die Variablen als private definiert sind und somit ein Zugriff nur von Funktionen der Klasse selbst erlaubt sind. Dies ist gängige Praxis in der objektorientierten Programmiersprache (kurz OOP). Nur Funktionen der Klasse (auch als Methoden bezeichnet) dürfen die Werte von Variablen lesen und ändern. private gehört wie protected und public zu den Zugriffsmodifzierern. public erlaubt, im Gegensatz zu private, den Zugriff „von außen“, d. h. Sie können auf Variablen und Funktionen außerhalb von Teilen der Klasse zugreifen. Der Zugriffsmodifizierer protected ist vergleichbar mit private. Der Unterschied ist einfach erklärt: Stellen Sie sich vor, es gibt eine Klasse Computer mit der Eigenschaft iArbeitsspeicher. Möchten Sie nun von einer weiteren Klasse (namens Notebook), welche von der Klasse Computer erbt, auf diese Eigenschaft zugreifen, so muss der Zugriffsmodifizierer protected sein. Mit private wäre dieser Zugriff nicht möglich. Der Zugriff „von außen“ bleibt aber auch bei protected weiterhin verwehrt.

Wie Ihnen sicherlich aufgefallen ist, wird bei der Instanziierung hinter dem Objektnamen ein rundes Klammernpaar notiert. Dabei handelt es sich um den Aufruf des Konstruktors. Der Konstruktor ist eine spezielle Methode einer Klasse, die automatisch bei der Erstellung der Instanz aufgerufen wird und im Programmcode nicht direkt aufgerufen werden kann. Der Konstruktor hat keinen Rückgabetyp (nicht zu verwechseln mit dem Rückgabetyp void, welcher darauf hinweist, dass die Funktion keinen Wert zurückgibt) und besitzt immer den gleichen Namen wie die Klasse. Die Parameter können beliebig gewählt werden. Auch das Überladen des Konstruktors ist durchaus möglich. Wird kein Konstruktor angegeben, so wird automatisch ein leerer Standard-Konstruktor (ohne Parameter) erstellt.

public Computer()
{
    iArbeitsspeicher = 16;
    dProzessorTakt = 2.4;
}

Möchten Sie eine Klasse erstellen, welche von einer anderen Klasse erbt (also dessen Variablen und Funktionen „übernimmt“ und den Typ erweitert), so benötigen Sie das Schlüsselwort extends in der Klassendeklaration. Die Implementierung einer Schnittstelle (engl. interface) kann über das Schlüsselwort implements angegeben werden. Beide Funktionalitäten sind natürlich völlig unabhängig voneinander.

public class Notebook extends Computer implements Serializable
{
    
}

Stellen Sie sich vor, die Übergabewerte einer Methode haben den gleichen Namen wie die Membervariablen der Klasse. Nun stehen Sie vor dem Problem, dass Sie dem Compiler mitteilen müssen, welche Variable Sie meinen (die lokale oder die der Klasse). Standardmäßig werden immer die lokalen Variablen (dazu zählen auch die Funktionsparameter) verwendet. Möchten Sie jedoch auf die Membervariablen zugreifen, so können Sie das Schlüsselwort this verwenden. Hierzu folgendes Beispiel:

public Computer(int iArbeitsspeicher, double dProzessorTakt)
{
    this.iArbeitsspeicher = iArbeitsspeicher;
    this.dProzessorTakt = dProzessorTakt;
}

Ein ähnliches Problem kann es geben, wenn die Kind- und Elternklasse (auch als Basisklasse bezeichnet) über Funktionen oder Variablen mit dem gleichen Namen verfügen. Möchten Sie von der Kindklasse explizit auf die Elternklasse zugreifen, so können Sie lediglich das Schlüsselwort super nutzen. Eine häufige Verwendung findet sich vor allem in Konstruktoren:

public Notebook(int iArbeitsspeicher, double dProzessorTakt, double dBildschirmGroesse)
{
    super(iArbeitsspeicher, dProzessorTakt);
    this.dBildschirmGroesse = dBildschirmGroesse;
}

Packages und Imports

In Java werden Klassen, Schnittstellen und Aufzählungen (Typ enum) in sogenannte Packages (zu Deutsch Pakete) eingeordnet. Das Package muss dabei in jeder Datei einmal angegeben werden:

package de.homepage-webhilfe.crashkurs;

Um Bestandteile von anderen Packages nutzen zu können, müssen Sie die Klasse, die Schnittstelle oder den Aufzählungstyp einbinden. Ein solcher Import muss außerhalb der Klasse etc. angegeben werden und wird mit dem Schlüsselwort import durchgeführt:

import java.util.ArrayList;

Auch das Einbinden eines kompletten Packages ist möglich. Hier kommt dann das Wildcard-Zeichen * zum Einsatz:

import java.util.*;

Fehlerbehandlungen

In Java gibt es einige Funktionen, welche Ausnahmefehler (engl. exceptions) auslösen können (man spricht auch davon, dass eine Exception geworfen wird). Diese Fehler können (und sollten) im Programmcode abgefangen werden. Dafür muss der Code, der einen Ausnahmefehler auslösen kann, innerhalb eines try-Blocks notiert werden. Natürlich darf dort auch Code notiert werden, welcher keinen Fehler auslösen kann. Der try-Block muss nun von einem oder mehreren catch-Blöcken gefolgt werden. Dort wird in runden Klammern eine Variable deklariert, welche die Informationen des Fehlers als Objekt von einer der Exceptionklassen enthält.

ArrayList<int> iZahlenliste = new ArrayList<int>();
try
{
    iZahlenliste.set(3, 123);    // löst eine Exception aus, da Index 3 größer als die Länge ist
}
catch (IndexOutOfBoundsException ex)
{
    // Fehler behandeln
}

Übrigens: Alle Exceptionklassen verfügen über die Methode printStackTrace(), welche ausführliche Informationen über den aufgetretenen Ausnahmefehler auf der Konsole ausgibt.

Übrigens: Möchten Sie nach Durchführung des try-Blocks (unabhängig ob ein Fehler ausgelöst wurde oder nicht) einen bestimmten Code ausführen, so können Sie nach den try-Blöcken einen finally-Block notieren. Dieser Block wird dazu verwendet, bestehende Ressourcen (wie z. B. eine Datei oder ein Netzwerksocket) zu schließen.