Java Grundlagen Cheatsheet

6 Kernkonzepte

Die wichtigsten Grundlagen von Java: Syntax · Variablen · Datentypen · Operatoren · Kontrollstrukturen · Strings Java ist eine der meistgenutzten Programmiersprachen – plattformunabhängig, objektorientiert und vielseitig. Diese Grundlagen sind der Einstieg in die Java-Programmierung.

Syntax – Die Grundregeln

class · main · ; · {} · //

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

Java-Syntax ist C-ähnlich und zeichnet sich durch geschweifte Klammern {} für Codeblöcke, Semikolons ; als Anweisungsende und eine strikte Groß-/Kleinschreibung aus.

Wichtige Syntax-Regeln

Regel	Beschreibung
//	Einzeiliger Kommentar
/* ... */	Mehrzeiliger Kommentar
/** ... */	Javadoc-Kommentar (für Dokumentation)
;	Semikolon beendet eine Anweisung (Pflicht!)
{}	Geschweifte Klammern definieren Codeblöcke
case-sensitiv	Java unterscheidet zwischen Groß- und Kleinschreibung
Dateiname	Muss mit dem Klassennamen übereinstimmen (Main.java)

Beispiele

// Einzeiliger Kommentar

/* Mehrzeiliger

Kommentar */

/** Javadoc-Kommentar für Dokumentation */

public class Beispiel {

public static void main(String[] args) {

System.out.println("Hallo"); // Semikolon Pflicht!

}

Tipp: In Java ist jede Anweisung mit einem Semikolon ; zu beenden – das ist Pflicht und führt bei Fehlen zu Compiler-Fehlern.

Variablen – Daten speichern

Typ name = wert;

int alter = 30; // Ganzzahl double preis = 19.99; // Gleitkommazahl String name = "Anna"; // String (Klasse) boolean aktiv = true; // Wahrheitswert

Variablen in Java müssen deklariert werden – mit einem expliziten Datentyp. Java ist statisch typisiert: der Typ einer Variable kann sich nicht ändern.

Regeln für Variablennamen

Regel	Beschreibung
Buchstaben, Ziffern, _, $	Erlaubte Zeichen (keine Sonderzeichen)
Nicht mit Ziffer	Name darf nicht mit einer Zahl beginnen
Groß-/Kleinschreibung	Java unterscheidet zwischen Groß- und Kleinschreibung
Reservierte Wörter	Nicht verwenden: class, int, if, for, etc.
Konventionen	camelCase für Variablen (empfohlen)

Beispiele

// Deklaration und Initialisierung

int x; // Deklaration

x = 10; // Initialisierung

// Mehrere Variablen

int a = 1, b = 2, c = 3;

// final = Konstante (unveränderbar)

final double PI = 3.14159;

// PI = 3.14; // Fehler!

Tipp: Verwenden Sie final für Konstanten – das signalisiert, dass der Wert sich nicht ändern soll und wird vom Compiler geprüft.

Datentypen – Primitive & Referenzen

int, double, boolean, char, String, Arrays

// Primitive Datentypen int zahl = 42; double komma = 3.14; boolean flag = true; char zeichen = 'A';

Datentypen in Java werden unterteilt in primitive Typen (int, double, boolean, char, etc.) und Referenztypen (Klassen, Arrays, Interfaces).

Die wichtigsten Datentypen

Typ	Kategorie	Beschreibung	Beispiel
int	Primitiv	Ganze Zahlen (32 Bit)	42, -7, 0
double	Primitiv	Gleitkommazahlen (64 Bit)	3.14, -0.5
boolean	Primitiv	Wahrheitswerte	true, false
char	Primitiv	Einzelnes Zeichen (16 Bit Unicode)	'A', '5', '\n'
byte	Primitiv	Kleine Ganzzahl (8 Bit)	127, -128
short	Primitiv	Kurze Ganzzahl (16 Bit)	32767, -32768
long	Primitiv	Große Ganzzahl (64 Bit)	100000L, -5L
float	Primitiv	Kurze Gleitkommazahl (32 Bit)	3.14f, -0.5f
String	Referenz	Zeichenkette (Klasse)	"Hallo", "Welt"
int[]	Referenz	Array von ints	{1, 2, 3}

Beispiele

// Primitive Typen

int i = 100;

double d = 99.9;

boolean b = false;

char c = 'Z';

long l = 123456789L; // L am Ende!

// Referenztypen

String text = "Hallo Welt";

int[] array = {1, 2, 3}; // Array-Initialisierung

Tipp: Für große Ganzzahlen verwenden Sie long mit dem Suffix L (z.B. 100000L). Für große Gleitkommazahlen mit float das Suffix f (z.B. 3.14f).

Operatoren – Rechnen & Vergleichen

+ - * / % · == != < > · && || !

int summe = 10 + 5; // 15 boolean gleich = (5 == 5); // true boolean result = (x > 0) && (x < 10);

Operatoren führen Berechnungen und Vergleiche durch. Java bietet eine breite Palette von arithmetischen, Vergleichs- und logischen Operatoren.

Die wichtigsten Operatoren

Kategorie	Operatoren
Arithmetik	+, -, *, /, % (Modulo)
Vergleich	==, !=, <, >, <=, >=
Logik	&& (UND), \|\| (ODER), ! (NICHT)
Zuweisung	=, +=, -=, *=, /=, %=
Inkrement/Dekrement	++, -- (vor oder nach dem Variablennamen)
Ternary	? : (bedingte Zuweisung)
Bitweise	&, \|, ^, ~, <<, >>, >>>

Beispiele

// Arithmetische Operatoren

int ergebnis = 10 / 3; // 3 (Integer-Division)

int rest = 10 % 3; // 1 (Rest)

// Vergleichsoperatoren

boolean istGleich = (5 == 5); // true

boolean istGroesser = (10 > 5); // true

// Logische Operatoren

boolean a = true, b = false;

boolean und = a && b; // false

boolean oder = a || b; // true

boolean nicht = !a; // false

// Ternary Operator

int max = (x > y) ? x : y;

Tipp: Der ternäre Operator ? : ist eine kompakte Alternative zu if-else für einfache Zuweisungen: int max = (a > b) ? a : b;

Kontrollstrukturen – if, for, while

if · else · for · while · do-while

if (x > 0) { System.out.println("Positiv"); } for (int i = 0; i < 5; i++) { System.out.println(i); } while (x > 0) { x--; }

Kontrollstrukturen steuern den Programmablauf – Bedingungen (if, else, switch) und Schleifen (for, while, do-while).

Die wichtigsten Kontrollstrukturen

Struktur	Beschreibung
if (bedingung) { ... }	Führt Block aus, wenn Bedingung true ist
if (bedingung) { ... } else { ... }	Alternative bei false
if (bedingung) { ... } else if (bedingung) { ... }	Mehrere Bedingungen prüfen
switch (wert) { case x: ... break; }	Mehrfachverzweigung (seit Java 14 auch mit ->)
for (init; bedingung; update) { ... }	Zählergesteuerte Schleife
for (Typ var : array) { ... }	For-Each-Schleife (für Arrays/Collections)
while (bedingung) { ... }	Kopfgesteuerte Schleife (prüft vorher)
do { ... } while (bedingung);	Fußgesteuerte Schleife (mindestens einmal)
break;	Beendet die aktuelle Schleife
continue;	Springt zum nächsten Schleifendurchlauf

Beispiele

// if-else

if (alter >= 18) {

System.out.println("Volljährig");

} else {

System.out.println("Minderjährig");

}

// for-Schleife

for (int i = 0; i < 5; i++) {

System.out.println(i);

}

// For-Each (enhanced for)

int[] zahlen = {1, 2, 3};

for (int z : zahlen) {

System.out.println(z);

}

// while-Schleife

int count = 0;

while (count < 5) {

System.out.println(count);

count++;

}

Tipp: Die For-Each-Schleife (for (Typ var : array)) ist die einfachste und sicherste Art, Arrays und Collections zu durchlaufen – kein Index, keine Indexfehler.

Strings – Text verarbeiten

String · .length() · .toUpperCase() · +

String text = "Hallo"; int laenge = text.length(); // 5 String gross = text.toUpperCase(); // "HALLO"

Strings sind Zeichenketten in Java. Sie sind unveränderbar (immutable) und bieten viele Methoden zur Textverarbeitung. String ist eine Klasse, kein primitiver Typ.

Wichtige String-Methoden

Methode	Beschreibung	Beispiel
length()	Länge des Strings	"Hallo".length() // 5
toUpperCase()	Alle Zeichen in Großbuchstaben	"hallo".toUpperCase() // "HALLO"
toLowerCase()	Alle Zeichen in Kleinbuchstaben	"HALLO".toLowerCase() // "hallo"
trim()	Leerzeichen am Anfang/Ende entfernen	" hallo ".trim() // "hallo"
split(regex)	Zerlegt String in String-Array	"a,b,c".split(",") // {"a","b","c"}
replace(old, new)	Ersetzt alle Vorkommen	"Hallo".replace('a','e') // "Hello"
contains(sub)	Prüft auf Teilstring	"Hallo".contains("ll") // true
startsWith(prefix)	Prüft auf Anfang	"Hallo".startsWith("Ha") // true
endsWith(suffix)	Prüft auf Ende	"Hallo".endsWith("lo") // true
indexOf(sub)	Findet Position (oder -1)	"Hallo".indexOf("ll") // 2
substring(start, end)	Extrahiert Teilstring	"Hallo".substring(0, 3) // "Hal"
charAt(index)	Gibt Zeichen an Position zurück	"Hallo".charAt(0) // 'H'
isEmpty()	Prüft auf leeren String	"".isEmpty() // true
isBlank()	Prüft auf leeren oder nur Leerzeichen (Java 11+)	" ".isBlank() // true

Beispiele

// String-Erstellung

String s1 = "Hallo"; // String-Literal

String s2 = new String("Welt"); // String-Objekt

// String-Konkatenation

String name = "Anna";

String begruessung = "Hallo " + name + "!";

// Methoden

String text = " Java Programmierung ";

System.out.println(text.trim()); // "Java Programmierung"

System.out.println(text.toUpperCase()); // " JAVA PROGRAMMIERUNG "

System.out.println(text.contains("Java")); // true

// String in Array zerlegen

String[] teile = "Apfel,Birne,Kirsche".split(",");

// teile = {"Apfel", "Birne", "Kirsche"}

// Teilstring

String wort = "Java";

System.out.println(wort.substring(1, 3)); // "av"

Tipp: Für viele String-Operationen (wie trim(), toUpperCase()) gibt es moderne Alternativen mit StringBuilder oder StringBuffer für bessere Performance bei vielen Änderungen.

Java Grundlagen im Überblick

main Einstiegspunkt
public static void main(String[] args)

statisch Starke Typisierung
Typ muss deklariert werden

; {} Semikolon & Blöcke
Pflicht für Anweisungen

String Zeichenketten
Unveränderbar (immutable)

== vs equals Vergleich bei Strings
.equals() für Inhalte

new Objekterzeugung
new Klasse()

Quick Summary

//

Kommentar

int x = 5

Variable

String

Text

==

Vergleich

if

Bedingung

.length()

String-Länge

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