Java Grundlagen

Ziele

• Ich weiss, was eine Klasse ist
• Ich weiss, was Variablen und Datentypen sind
• Ich kenne die primitiven Datentypen in Java: boolean, byte, short, int, long, double, float, char
• Ich kenne die Klasse String
• Ich kenne Arrays und kann diese instanzieren, ihnen Werte von Indexen entnehmen und Werte an Indexe zuweisen
• Ich kann eine Variable deklarieren und initialisieren
• Ich weiss, was eine statische Methode ist und kann sie aufrufen
• Ich verstehe den Unterschied zwischen Methoden mit und ohne Rückgabewert
• Ich kann eine Methodensignatur für Methoden mit und ohne Rückgabewert richtig schreiben
• Ich kann Methoden schreiben, die Parameter entgegennehmen
• Ich weiss, dass jede Anweisung mit einem Strichpunkt abgeschlossen werden muss
• Ich weiss, dass geschweifte Klammern einen Block definieren und ich verwende sie in jeder Kontrollstruktur, um die Code-Blocks voneinander abzugrenzen (lieber zu viel klammern als zu wenig)
• Ich kenne die Main-Methode und weiß, warum eine Applikation nur EINE Main-Methode haben sollte
• Ich kenne die Methode ‘System.out.println’ und kann sie anwenden
• Ich kann eine Eingabe von der Konsole lesen und in einer Variablen speichern
• Ich kann arithmetische Ausdrücke schreiben: Addition, Subtraktion, Multiplikation, Division, Modulo (Rest einer Division)
• Ich kenne die relationalen Operatoren: ==, >=, <=, >, <, !=
• Ich kenne die booleschen Operatoren: && (AND), || (OR), ! (NOT), ^(XOR)
• Ich weiß, was eine bedingte Anweisung ist und kann sie korrekt anwenden
• Ich kann eine Schleife programmieren: for, foreach, while und do-while
• Ich kenne die switch-Anweisung

Änderungskontrolle

Cheatsheet zum Downloaden

Einführung

Was ist Java?

Java ist eine objektorientierte Programmiersprache, die schon seit ca. zwei Jahrzehnten große Popularität genießt. Die Entwicklung von Java begann Anfang der 1990er-Jahre beim US-amerikanischen Hard- und Softwarehersteller Sun Microsystems. 1995 wurde die erste Version veröffentlicht. 2010 wurde Sun Microsystems von Oracle übernommen. Gegenwärtig erscheinen im Halbjahrestakt neue Java-Versionen; die neuste Version, Java 16, wurde im März 2021 veröffentlicht.

Wichtigste Merkmale von Java

Plattformunabhängigkeit

«Write once, Run anywhere»

Der Compiler wandelt den Quellcode in Bytecode um (Kompilat) und anschliessend führt die Java Virtual Machine (JVM) den Bytecode aus. Jedes Betriebssystem hat eine andere JVM, aber jede JVM kann den Bytecode ausführen, daher kann ein- und dieselbe Java-Anwendung auf Windows, Linux, Mac OS und anderen Plattformen lauffähig sein.

Mehrfach-Paradigma

Java ist in erster Linie eine objektorientierte und imperative Programmiersprache, bei der fast alles ein Objekt einer Klasse (eines Typs) ist. Wir können ein typisches Java-Programm als eine Menge von interagierenden Objekten betrachten. Die Objekte können Entitäten aus der realen Welt oder eine Art von Programmierabstraktionen darstellen. Wenn wir ein Programm schreiben, erklären wir, wie die Objekte miteinander interagieren sollen. Java unterstützt aber auch andere Programmierparadigmen, darunter generische Programmierung, parallele Programmierung, funktionale Programmierung (teilweise unterstützt) und andere.

Garbage Collector

Der Garbage Collector (Teil der JVM) führt zur Laufzeit eine automatische Speicherbereinigung von unbenutzten Objekten durch. Der Entwickler muss sich also nicht um das Aufräumen von unbenutzen Objekten kümmern.

Multithreading

Java unterstützt Multithreading auf der Ebene der Sprache und der Standardbibliothek. Es ermöglicht die gleichzeitige und parallele Ausführung mehrerer Teile eines Java-Programms.

Code, Compile, Run

Ein/e Java-Entwickler/in schreibt ein Programm in eine Textdatei mit der Erweiterung .java. Ein Programm kann eine Vielzahl solcher Dateien enthalten. Dann übersetzt der Compiler (normalerweise javac) das Programm in eine .class-Datei, die den Bytecode des Programms enthält. Danach führt die JVM das Programm aus und gibt Low-Level-Befehle an den Computer. Der Computer ist hier eine Abstraktion, welche ein Server, ein PC oder sogar ein mobiles Gerät sein kann. Tatsächlich sind die Prozesse komplexer, als hier gezeigt wird. Es ist wichtig, Folgendes zu verstehen: Der Teil vor der JVM ist plattformunabhängig, der Teil nach der JVM ist plattformabhängig.

Terminologie

Hello World

Anhand des simplen Hello-World-Programms können wir bereits vieles über die zentralen Bestandteile einer Java-Anwendung erklären. Der folgende Sourcecode ist in einer Datei mit dem Namen HelloWorld.java abgelegt.

1
2
3
4
5

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
    }
}

Public class

Bei diesem Beispiel arbeiten wir uns nun von aussen nach innen vor. Der erste Teil definiert eine neue Klasse mit dem Namen HelloWorld. Die Deklaration der Klasse besteht aus dem Zugriffsmodifizierer public (dazu später mehr) gefolgt vom Keyword class und dem Klassennamen. Jede Java-Datei darf nur eine Klasse mit dem Zugriffsmodifizierer public enthalten, weitere Klassen ohne public sind jedoch erlaubt. Der Name der Klasse mit dem Modifizierer public muss stets mit dem Dateinamen übereinstimmen. Der Klassenname wird stets gross geschrieben, einzelne Wörter werden durch einen erneuten Grossbuchstaben getrennt. Dies wird CamelCase genannt. Der Block der Klasse wird durch geschweifte Klammern angegeben.

Die Main-Methode

Innerhalb der Klasse wird nun eine Main-Methode definiert. Diese Methode ist der Einstiegspunkt eines jeden Java-Programms. Nur über eine solche Methode kann eine Java-Anwendung gestartet werden. Die Methode besteht aus dem Zugriffsmodifizierer public, dem Keyword static, dem Rückgabewert void und dem Methodennamen main. An den Namen der Methode schliesst sich ein paar runde Klammern an. Innerhalb dieser Klammern befinden sich die Parameter der Methode, in diesem Fall handelt es sich um ein String-Array. Die Angabe der genannten Teile einer Methode nennt man Methodensignatur. Der Block der Methode wird durch geschweifte Klammern angegeben. Die Main-Methode hat immer die oben gezeigte Signatur.

“Hello World” ausgeben

Innerhalb der Main-Methode sehen wir ein einzelnes Statement. Es besteht aus einer einfachen Anweisung, welche den Text “Hello, world!” auf die Kommandozeile ausgibt. Die statische Methode println() auf dem öffentlich zugänglichen Feld der Klasse System dient dazu Text auf der Konsole auszugeben. Das Statement wird mit einem Semikolon abgeschlossen.

Variablen

Namensgebung

Variablen dienen dazu Werte aufzunehmen. Je nach Scope leben diese Variablen unterschiedlich lang. Zur Benennung von Variablen gibt es vier Regeln:

• Variablennamen beginnen mit einem Kleinbuchstaben
• Ein Variablenname darf die Buchstaben A-Z und a-z enthalten
• Ein Variablenname darf beliebige Zahlen von 0-9 enthalten
• Ein Variablenname darf die Sonderzeichen $ und _ enthalten

Best Practices

Der Name einer Variable sollte so gewählt werden, dass klar ist, welcher Wert darin gespeichert wird. Als Beispiel wählen wir den Namen sum für eine Variable, welche das Resultat einer Addition enthält.

Deklaration

Unter der Deklaration einer Variable versteht man das erste “Erwähnen” einer Variable. In einer statisch typisierten Sprache wie Java bedeutet dies, dass der Typ der Variable festgelegt wird. Der Wert selbst muss bei der Deklaration je nach Scope nicht festgelegt werden. Zur Laufzeit wird für die Variable ein Bereich im Arbeitsspeicher reserviert. Hier werden später Werte, die der Variablen zugewiesen werden, gespeichert. Die Größe des Speicherbereichs hängt vom Typ der Variable ab.

Formal gilt:

1

<variable type> <variable identifier>;

Wir geben also den Datentyp und den Namen der Variable an.

Initialisierung

Unter dem Begriff Initialisierung wird die direkte Zuweisen eines Wertes bei der Deklaration einer Variablen verstanden. Lokale Variablen (Variablen, die lediglich innerhalb einer Methode gültig sind) müssen initialisiert werden, bevor sie verwendet werden können.

Beispiel:

1
2
3
4
5

public static void main(String[] args) {
	int firstSummand = 2;
	int secondSummand;
	int sum = firstSummand + secondSummand;
}

Die Variable secondSummand wurde nicht initialisiert. Die Zuweisung int sum = firstSummand + secondSummand wird also nicht funktionieren.

Deklaration mit Initialisierung

Wir können eine Variable nacheinander deklarieren und dann initialisieren oder beides zusammen:

1
2
3
4

int number;     // 1. Deklaration
number = 2;     // 2. Initialisierung

int number = 2; // beides in einer Zeile

Formal:

1

<variable type> <variable identifier> = <initial value>;

Datentypen

In Java sind Variablen stark typisiert. Das heisst, dass alle Variablen bei ihrer Erstellung mit einem Datentyp versehen werden müssen. Seit Java 10 gibt es Typinferenz für lokale Variablen, das heisst, eine lokale Variable kann deklariert und initialisiert werden (muss gleichzeitig geschehen), ohne dass ein Datentyp angegeben werden muss - anstelle des Datentyps kann var verwendet werden:

1

var sum = 20;

Es gibt zwei Arten von Datentypen: Primitive Datentypen und Referenztypen. Der grundlegende Unterschied besteht darin, dass eine primitive Variable den tatsächlichen Wert speichert, während eine Referenzvariable die Adresse des Objekts speichert, auf welches sie sich bezieht. Dies hat mit dem Java Memory Modell zu tun. Das nachfolgende Bild zeigt das Java Memory Modell als einfache Darstellung, es besteht grundsätzlich aus dem Stack Memory und dem Heap Space. Primitive Datentypen werden nur auf dem Stack angelegt. Objekte, wie das im Bild gezeigte Auto (Car), sind im Heap abgelegt. Die Referenz auf das Objekt wird auf dem Stack angelegt. Die Referenz “zeigt” also auf das Objekt im Heap.

Dieser fundamentale Unterschied ist relevant beim Vergleich von Werten und Referenzen. Der Operator für den Vergleich ==, vergleicht stets die Werte auf dem Stack miteinander. Bei Referenzen wird dort also überprüft, ob sie auf dasselbe Objekt zeigen. Wenn der Inhalt von Objekten verglichen werden soll, so muss dies mit der Methode equals gemacht werden.

Primitive Datentypen

Integraler Datentyp

Integrale Datentypen sind immer ganze Zahlen, sie besitzen also keine Nachkommastellen. Die folgenden Datentypen speichern ganzzahlige Werte, sie unterscheiden sich nur in ihrer Grösse:

In den Werten von integralen Datentypen sind Underscores erlaubt, um die Lesbarkeit zu erhöhen (1_000_000).

Beispiele:

1
2

int count = 0;
int million = 1_000_000;

Gleitkomma-Datentyp

Gleitkomma-Datentypen speichern wie der Name bereits sagt, Zahlen mit Nachkommastellen. Diese Zahlen besitzen nur eine bestimmte Genauigkeit, sie dürfen also nicht als unendlich genau betrachtet werden. Die folgenden Datentypen speichern Zahlen mit Nachkommastellen, sie unterscheiden sich in ihrer Grösse und der Art und Weise wie sie innerhalb von Java abgelegt werden:

Beispiele:

1
2

float radius = 8.5f;
double area = 16.48739d;

Trotz Nachkommastellen dürfen Fliesskommzahlen des Typs float niemals zur Berechnung von Währungen verwendet werden. Innerhalb von Java wird ein float stets als Dezimalbruch geführt und die Ungenauigkeit verunmöglicht es diesen Datentyp für Währungsrechnungen zu verwenden.

Zeichen-Datentyp

Ein char ist ein (vorzeichenloser) 16-Bit-Integer-Datentyp, der ein einzelnes Zeichen darstellt. Dieser Datentyp erlaubt die Repräsentation von Zeichen im so genannten Unicode-Zeichensatz.

Ein einzelnes Zeichen kann eine Ziffer, einen Buchstaben oder ein anderes Symbol sein. Um ein Zeichen zu schreiben, verwenden wir einfache Anführungszeichen wie folgt:

1

'A', 'B', 'C', 'x', 'y', 'z', '0', '1', '2', '9'

Zeichenliterale können Symbole eines Alphabets, Ziffern von ‘0’ bis ‘9’, Whitespaces (' ‘) oder andere Zeichen oder Symbole ('$') darstellen. Verwechsle nicht die Zeichen, die Zahlen (‘9’) darstellen mit den Zahlen selbst (9). Ein Zeichen kann nicht zwei und mehr Ziffern oder Buchstaben enthalten, da es nur ein einziges Symbol darstellt.

Wir können Zeichen auf verschiedene Arten initialisieren:

Beispiele:

1
2
3

char letter = 'a';
char point = '.';
letter++; // 'b'

Don’t get confused:

• 123 ist ein Integer, “123” ist ein String;
• ‘A’ ein Zeichen (char), “A” ist ein String;
• ‘1’ ist ein Zeichen (char), 1 ist ein Integer;

Logischer Datentyp

Dieser Datentyp bezieht sich nur auf die zwei Werte true und false.

1
2

boolean done = false;
boolean isBigger = true;

Referenztypen

Nebst primitiven Datentypen gibt es Referenzdatentypen. Eine Variable diesen Typs enthält nicht die Werte selbst wie eine Variable primitiven Typs, sondern nur einen Verweis (Referenz) auf den
Speicherort der Daten. Der Standardwert von Referenzvariablen ist null, welcher besagt, dass die Variable auf kein Objekt verweist.

Es gibt zwei Unterarten von Referenztypen:

1. Array: Eine Datenstruktur fester Grösse, die dazu dient, mehrere Elemente gleichen Typs zu speichern
2. Objektdatentyp, repräsentiert ein beliebiges Objekt

Arrays

Definition

Häufig benötigen Software-Entwickler mehrere zusammengehörige Variablen desselben Datentyps, die logisch oder verwaltungstechnisch zusammengehören. Es wäre aber sehr aufwendig, diese Variablen alle einzeln zu deklarieren und zu verarbeiten. Zudem ist es möglich, dass die Anzahl an Objekten noch unbekannt ist und erst bei der Ausführung des Programms definiert wird. Deswegen wird in Java, wie in anderen Programmiersprachen auch, die Verwendung von Arrays unterstützt. In Arrays lassen sich beliebige primitiven Datentypen und Objekte speichern und systematisch bearbeiten. Alle Variablen haben einen gemeinsamen Namen, werden aber über unterschiedliche Indizes angesprochen.

Deklaration

Die Deklaration eines Arrays enthält folgende Bestandteile:

1

String[] words;

Länge eines Arrays

Die Anzahl der Elemente in einem Array wird als Länge eines Arrays bezeichnet. Diese Länge wird zum Zeitpunkt der Erstellung eines Arrays einmal festgelegt. Sie kann später in einem Programm nur durch Definition eines neuen Arrays und dem Kopieren von Werten geändert werden.

Wir können die Länge eines Arrays mithilfe einer in Java integrierten Funktionalität überprüfen:

1

words.length

Indizierung

Die Indizes in einem Array reichen immer von 0 bis length-1. Ein Array mit den ersten 100 natürlichen Zahlen hat beispielsweise eine Länge von 100 und Indizes von 0 bis 99.

Syntax

In Java müssen wir zum Zeitpunkt der Deklaration eines Arrays folgendes angeben:

• den Datentyp
• den Namen

und zum Zeitpunkt der Initialisierung:

• die Größe

Syntaktisch können wir ein Array eines ganzzahligen Datentyps auf folgende Weise deklarieren:

1
2

String[] words;
String words[];

Die zweite Form wird bei uns nicht verwendet.

Dieser Code deklariert die Variable words, erstellt das Array-Objekt jedoch noch nicht. Der Operator new wird in Java zum Erstellen von neuen Objekten verwendet.

1

String[] words = new String[5];

Damit wird ein Array-Objekt der Länge 5 instanziiert. Die fünf Elemente dieses Arrays wurden mit Standardwerten initialisiert. Bei einem Array des Datentyps String ist der Default-Wert null. Alle Werte im Array werden also mit null aufgefüllt.

Wir können auch direkt die Werte der Array-Elemente angeben:

1

String[] words = { "Hai", "Oktopus", "Rochen", "Wal", "Fisch" };

Es wird also ein Array mit der Grösse 5 und den angegebenen Werten erstellt.

Zugriff auf Elemente

Wenn wir den Wert eines Elements in unserem Array verändern möchten, geschieht dies folgendermaßen:

1

words[index] = value;

Wenn wir den Wert eines Array-Elements in einer Variablen außerhalb des Arrays speichern wollen:

1

String value = words[index];

String

Eine Variable, die eine Zeichenkette enthält, hat den Typ String.

1

String hello = "Hello, Java";

Diese Zeichenkette besteht aus 11 Zeichen, einschließlich eines Leerzeichens. Wie wir hier ebenfalls sehen, müssen String-Literale von doppelten Anführungszeichen umgeben sein. Ein Objekt des Typs String ist unveränderlich, die Werte innerhalb eines Strings können also nach dessen Erstellung nicht mehr verändert werden.

Methoden

Der folgende Code zeigt die Verwendung einiger Methoden der Klasse String. Alle Methoden sind in der API unter https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html zu finden.

  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
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

public class StringMethoden {
    public static void main(String\[\] args) {
        String house = "house";

        /**
         * Returns the char value at the specified index (indexing starts from 0)
         */
        char o = house.charAt(1);

        /**
         * Returns the length of this string.
         */
        int length = house.length();

        /**
         * Returns true if and only if this string contains the specified sequence of char values
         */
        boolean isContaining = house.contains("us");

        /**
         * Returns the index within this string of the first occurrence of the specified character
         */
        int indexChar = house.indexOf('s');

        /**
         * Returns the index within this string of the first occurrence of the specified substring
         */
        int indexSubstring = house.indexOf("us");

        /**
         * Tests if this string starts with the specified prefix
         */
        boolean startsWithPrefix = house.startsWith("Ho"); // false
        boolean startsWithPrefix2 = house.startsWith("ho"); // true

        /**
         * Tests if this string ends with the specified suffix
         */
        boolean endsWithSuffix = house.endsWith("se"); // true

        /**
         * Returns a new string resulting from replacing all occurrences of oldChar in this string with newChar
         */
        String mouse = house.replace('h', 'm');
        String houseHouse = "House, House";
        String mouseMouse = houseHouse.replace('H', 'M');

        /**
         * Returns a new string that is a substring of this string, starting from the specified index
         */
        String applePearLemon = "Apple, pear, lemon";
        String pearLemon = applePearLemon.substring(7);

        /**
         * Returns a new string that is a substring of this string
         */
        String pear = applePearLemon.substring(7, 11);

        /**
         * Converts all of the characters in this String to upper case
         */
        String apple = "Apple";
        String appleUpperCase = apple.toUpperCase(); // APPLE

        /**
         * Converts all of the characters in this String to lower case.
         */
        String appleLowerCase = apple.toLowerCase(); // apple

        /**
         * Splits this string around matches of the given regular expression, puts them in a String array
         */
        String applePear = "Apple, pear";
        String[] fruits = applePear.split(",\\s"); // \\s means whitespace

        /**
         * Converts this string to a new character array
         */
        char[] charArray = applePearLemon.toCharArray();

        /**
         * Compares this string to the specified object
         */
        String appleOne = "Apple";
        String appleTwo = "Apple";
        boolean isEqual = appleOne.equals(appleTwo);

        /**
         * Compares two strings lexicographically.
         * The comparison is based on the Unicode value of each character in the strings. 
		 * The result is a negative integer if this String object lexicographically precedes the argument string.
		 * The result is a positive integer if this String object lexicographically follows the argument string.
		 * The result is zero if the strings are equal
         */
        String abcd = "abcd";
        String cdef = "cdef";

        if (abcd.compareTo(cdef) < 0) {
            System.out.println(abcd + " precedes " + cdef);
        }

        if (house.compareTo(house) == 0) {
            System.out.println(house + " is equal to " + house);
        }

        if (cdef.compareTo(abcd) > 0) {
            System.out.println(cdef + " follows " + abcd);
        }

        /**
         * Capital letters precede lower case letters
         */
        String houseLowerCase = "house";
        String houseUpperCase = "HOUSE";
        if (houseLowerCase.compareTo(houseUpperCase) > 0) {
            System.out.println(houseUpperCase + " precedes + " houseLowerCase);
        }

        /**
         * Compares two strings lexicographically, ignoring case differences
         */
        System.out.println(houseLowerCase.compareToIgnoreCase(houseUpperCase));
    }
}

Scanner

Eine Möglichkeit, Benutzereingaben in Java vorzunehmen, besteht in der Verwendung der Scanner-Klasse, die verwendet wird, indem zuerst die Definition der Klasse wie in Zeile 1 importiert und dann ein Objekt dieser Klasse wie in Zeile 6 erstellt wird.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import java.util.Scanner;

public class TakeInput {
    public static void main (String\[\] args) {
	    Scanner scanner = new Scanner(System.in);
		System.out.println("Enter your name: ");
		String name = scanner.nextLine();
		System.out.println("Your name is: " + name);
    }
}

Zeile 1

Der erste Schritt besteht darin, die Scanner-Klasse zu importieren, damit sie im folgenden Code verwendet werden kann. Die Java Scanner-Klasse stammt aus dem Paket java.util. Es ist einfach zu bedienen, muss jedoch importiert werden, damit die Klasse funktioniert.

Zeile 6

• Wir deklarieren den Datentyp als Scanner und geben ihm den Bezeichner scanner
• Wir weisen der Variable scanner ein neues Objekt zu, welches den System-Eingabestream enthält (System.in)

Zeile 8

• Wir deklarieren eine Variable vom Datentyp String mit dem Bezeichner name
• Wir weisen der Variable name das Resultat der Methode scanner.nextLine() zu
• Diese Methode nimmt die Tastatureingabe vom Benutzer auf der Kommandozeile entgegen. Sie wird beendet, wenn der Benutzer die Enter-Taste drückt

Statische Methoden

Mittlerweile hast du bereits einige statische Methoden kennengelernt, wie zum Beispiel die Main-Methode oder die Methode println() der Klasse System oder die Methode valueOf() der String-Klasse. Hier wollen wir uns nun genauer anschauen, was statische Methoden sind, denn diese wirst du unter anderem für das Lösen der Übungen benötigen. Das Keyword static ist ein sehr nützliches Werkzeug in Java. Bei statischen Methoden sind einige wichtige Punkte zu beachten.

• Diese Methoden gehören nicht zu einer Referenz von einem bestimmten Objekt
• Diese Methoden werden über den Klassennamen aufgerufen und nicht über eine Referenz von einem bestimmten Objekt

Wenn also in einem Methodenkopf das Keyword static steht, dann weisst du, dass es sich um eine statische Methode handeln muss. Schauen wir uns unterschiedliche Methodendeklarationen an (folgendes gilt für statische Methoden wie auch für nicht-statische Methoden): Wenn eine Methode einen Wert an ihren Aufrufer zurückgeben soll, sprechen wir von einer Methode mit einem Rückgabewert:

1
2
3

public static returnType methodName() {
    return returnValue; // der Typ des Rückgabewerts muss vom Typ sein, welcher im Methodenkopf steht
}

Wir sehen, dass in der Methodendeklaration angeben werden muss, welcher Typ zurückgegeben wird.

Wenn eine Methode keinen Wert zurückgegeben soll, verwenden wir das Keyword void:

1
2
3

public static void methodName() {
    
}

Das Keyword return ist in Methoden ohne Rückgabewert weiterhin zulässig um die Methode zu verlassen. Die Angabe eines Rückgabewerts entfällt in diesem Fall.

Wir können auch Werte einer Methode übergeben – hierbei sprechen wir von Parametern.

1
2
3

public static void methodName(type identifier) {
    
}

Ein Parameter besteht immer aus dem Datentyp und einem Bezeichner. Wir können beliebig viele Parameter an eine Methode übergeben. Gemäss den SBB Code Conventions (Regeln für den Programmcode) sollte eine Methode nicht mehr als acht Parameter haben.

Regeln

• Die Reihenfolge der Schlüsselwörter im Methodenkopf darf nicht verändert werden
• Bei der Auswahl des Methodennamens müssen die gleichen Regeln wie bei der Benennung einer Variablen eingehalten werden
• Keine doppelten Methoden: Jede Methodensignatur darf in einer Klasse nur einmal vorkommen

Aufruf

Innerhalb der gleichen Klasse

1

methodName();

Ausserhalb:

1

ClassName.methodName();

Mathematik & Logik

Mathe in Java ist sehr einfach. Beachte, dass mathematische Java-Operationen einer bestimmten Reihenfolge folgen (Punkt-Operationen vor Strich-Operationen)

Arithmetische Operatoren

Post- und Prä-Inkrement

Das Inkrementieren und Dekrementieren von Variablen ist eine sehr häufige Operation. Von diesem Operator gibt es zwei Varianten:

• Er kann vor der Variable stehen, wie in ++i (Präfix-Schreibweise) oder
• dahinter, wie bei i++ (Postfix-Schreibweise)

Der Präfix-Operator verändert die Variable vor der Auswertung der Programmzeile, und der Postfix-Operator ändert sie nach der Auswertung der Programmzeile. Mit anderen Worten: Nutzen wir einen Präfix-Operator, so wird die Variable erst herauf- bzw. heruntergesetzt und dann der Wert geliefert. Und beim Post-Operator ist es genau umgekehrt.

Postinkrement

1
2
3

int i = 5;
int c = i++; // c = 5
// ab hier ist i = 6

Präinkrement

1
2

int i = 5;
int d = ++i; // d = 6

Postdekrement

1
2
3

int i = 5;
int e = i--; // e = 5
// ab hier ist i = 4

Prädekrement

1
2

int i = 5;
int f = --i; // f = 4

Vegleichsoperatoren

Die Ergebnisse dieser Operationen sind stets Boolean-Werte.

Boolsche Operatoren

Diese Operatoren basieren auf der boolschen Algebra. Daher arbeiten boolsche Operatoren direkt mit boolschen Werten. Es gibt vier Arten von boolschen Operatoren. Schauen wir uns zunächst ihre Symbole und deren Inhalt in der folgenden Tabelle an, bevor wir erläutern, welche Funktionen sie ausführen.

Kontrollstrukturen

Kontrollstrukturen dienen dazu, den Ablauf eines Programms zu steuern. Damit bietet eine Kontrollstruktur die Möglichkeit, Programmteile nur unter gewissen Bedingungen ( → bedingte Anweisungen) auszuführen oder Programmteile zu wiederholen ( → Schleifen).

Bedingte Anweisungen

Eine bedingte Anweisung ist eine Konstruktion, mit der ein Programm abhängig vom Wert eines boolschen Ausdrucks (true oder false) unterschiedliche Wege geht.

If-Statement

Die einfachste Form der bedingten Anweisung besteht aus dem Schlüsselwort if, einem boolschen Ausdruck und einem Block.

1
2
3

if (expression) {
    
}

Wenn der Ausdruck true ist, werden die Anweisungen im Codeblock ausgeführt. Andernfalls werden sie übersprungen.

If-Else Statement

Der obige if-Fall kann mit dem Schlüsselwort else erweitert werden, um alternative Aktionen auszuführen, wenn der Ausdruck false ist.

1
2
3
4
5

if (expression) {
    // do something
} else {
    // do something else
}

Im folgenden Beispiel gibt das Programm je nach Wert von num (gerade oder ungerade) unterschiedlichen Text aus.

1
2
3
4
5
6

int num = ...; 	// the num is initialized by some value
if (num % 2 == 0) {
    System.out.println("It's an even number");
} else {
    System.out.println("It's an odd number");
}

Da eine Zahl nur gerade oder ungerade sein kann, wird nur eine der beiden Ausgaben gemacht.

Else-If-Statements

Ein Else-Statement kann durch ein If-Statement erweitert werden.

1
2
3
4
5
6
7
8
9

if (expression0) {
    // do something
} else if (expression1) {
    // do something else 1
} else if (expressionN) {
    // do something else N
} else {
    // in all other cases: do this…
}

Wenn also der erste Ausdruck false ist, wird der zweite Ausdruck überprüft, usw.

Beispiel:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

long dollars = ...; // your budget
if (dollars < 1000) {
    System.out.println("Buy a laptop");
} else if (dollars < 2000) {
    System.out.println("Buy a personal computer");
} else if (dollars < 100_000) {
    System.out.println("Buy a server");
} else {
    System.out.println("Buy a data center or a quantum computer");
}

Switch-Statement

Die Switch-Anweisung bietet eine Möglichkeit, basierend auf dem Wert einer einzelnen Variablen (kein Ausdruck!) zwischen mehreren Fällen zu wählen. Die Variable kann eine Ganzzahl, ein Zeichen, eine Zeichenfolge oder eine Aufzählung sein.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

switch (variable) {
    case value1:
        // do something here
        break;
    case value2:
        // do something here
        break;
    //... other cases
    case valueN:
        // do something here
        break;
    default:
        // do something by default
        break; // it can be omitted
}

Die Schlüsselwörter switch und case werden hier immer benötigt. Die Schlüsselwörter break und default sind optional. Das Schlüsselwort break verlässt die Switch-Anweisung. Wenn ein Fall nicht über das Keyword break verfügt, wird auch der darauffolgende Fall ausgewertet. Dies ist spannend, um die einzelnen Auswertungen verketten zu können. Der Default-Fall wird ausgewertet, wenn kein Fall mit dem Variablenwert übereinstimmt.

Schleifen (Loops)

Manchmal müssen wir einen Codeblock für eine bestimmte Anzahl wiederholen. Zu diesem Zweck stellt Java die Schleife bereit. Diese Schleife wird häufig verwendet, um über einen Wertebereich oder durch ein Array zu iterieren. For-Loops arbeiten mit einem Schleifenzähler, welcher sehr gut für Indizes von Arrays verwendet werden kann. Bei allen Schleifen ist Vorsicht geboten, da es rasch zu einer unendlichen Anzahl von Ausführungen kommen kann.

For-Loop

1
2
3

for (initialization; condition; modification) {
    // do something
}

• Bevor die Schleife beginnt, wird einmal die Initialisierungsanweisung (initialization) ausgeführt. Wir bezeichnen diese Variable als Schleifenvariable. Es sind mehrere Schleifenvariablen erlaubt, sie können durch Kommas getrennt werden.
• Die Bedingung (condition) ist ein boolscher Ausdruck, der die Notwendigkeit der nächsten Iteration bestimmt. Wenn die Auswertung der Bedingung false ist, wird die Schleife beendet – ansonsten folgt eine weitere Iteration
• Die Modifikation ist eine Anweisung, die den Wert der Schleifenvariablen verändert. Sie wird nach jeder Iteration aufgerufen. Normalerweise wird der Wert der Variable inkrementiert oder dekrementiert.

Beispiel:

1
2
3
4
5

int n = 9;
for (int i = 0; i <= n; i++) {
    System.out.print(i + " ");
}
// Output: 0 1 2 3 4 5 6 7 8 9

Innerhalb des Schleifenkörpers kann das Programm wiederum alle möglichen Java-Anweisungen ausführen. Es kann sogar andere Schleifen enthalten. Wie bei allen Blöcken sind die Schleifenvariablen nur innerhalb des Schleifenkörpers sichtbar. Die Schleifenvariable wird meistens mit einfachen Variablennamen wie i, j, k oder index benannt.

Hier ist ein weiteres Beispiel. Berechnen wir die Summe der Ganzzahlen von 1 bis 10 mit der for-Schleife.

1
2
3
4
5
6
7
8
9

int startIncl = 1;
int endExcl = 11;
int sum = 0;

for (int i = startIncl; i < endExcl; i++) {
    sum += i;
}

System.out.println(sum); // Output: 55

For-Each Loop

Der For-Each-Loop durchläuft alle Elemente eines Arrays oder einer Collection. Die Angaben aus dem For-Loop werden durch eine Schleifenvariable und ein Doppelpunkt ersetzt.

1
2
3
4
5

int[] numbers = { 125, 381, 98, 12, 235 };
for (int number: numbers) {
    System.out.print(number + " ");
}
// Output: 125 381 98 12 235

Der gezeigte Loop wird also fünfmal ausgeführt und der Wert der Variable number nimmt bei jedem Durchlauf den jeweils nächsten Wert aus dem Array an.

While-Loop

Die while- Schleife besteht aus einem Codeblock und einer Bedingung (einem booleschen Ausdruck). Wenn die Bedingung erfüllt ist, wird der Code innerhalb des Blocks ausgeführt. Dieser Code wird solange wiederholt, bis die Bedingung nicht mehr erfüllt ist.

1
2
3

while (condition) {
    // body: do something
}

Innerhalb des Schleifenkörpers kann das Programm wiederum alle möglichen Java-Anweisungen ausführen. Es kann sogar andere Schleifen enthalten.

Beispiel: Die folgende Schleife gibt Ganzzahlen aus, während eine Variable kleiner als 5 ist.

1
2
3
4
5
6
7

int i = 0;

while (i < 5) {
    System.out.print(i + " ");
    i++;
}
// Output: 0 1 2 3 4

Do-While Loop

Die Do-While-Schleife besteht aus einem Codeblock und einer Bedingung (einem boolschen Ausdruck) am Ende. Im Gegensatz zur While-Schleife wird die Do-While-Schleife mindestens einmal ausgeführt, da die Bedingung am Ende steht.

1
2
3

do {
    // body: do something
} while (condition);