☕ Java Grundlagen

Informatik - Teil 1: Variablen, Datentypen, Kontrollstrukturen und Methoden

1. Was ist Java?

📖 Definition

Java ist eine objektorientierte Programmiersprache, die von Sun Microsystems entwickelt wurde. Java-Programme werden in Bytecode kompiliert, der auf jeder Plattform mit einer Java Virtual Machine (JVM) ausgeführt werden kann.

Wichtige Eigenschaften von Java:

  • Plattformunabhängig: "Write once, run anywhere" – Der kompilierte Bytecode läuft auf allen Betriebssystemen
  • Objektorientiert: Alles in Java ist Teil von Klassen und Objekten
  • Typsicher: Jede Variable muss einen Datentyp haben
  • Automatische Speicherverwaltung: Der Garbage Collector räumt nicht mehr benötigten Speicher auf

🔧 Der Aufbau eines Java-Programms

Jedes Java-Programm besteht mindestens aus einer Klasse mit einer main-Methode:

public class MeinProgramm {
    public static void main(String[] args) {
        // Hier steht der Programmcode
        System.out.println("Hallo Welt!");
    }
}

Erklärung:

  • public class MeinProgramm – Definiert eine öffentliche Klasse namens "MeinProgramm"
  • public static void main(String[] args) – Die Hauptmethode, Einstiegspunkt des Programms
  • System.out.println() – Gibt Text auf der Konsole aus

2. Variablen

📖 Was ist eine Variable?

Eine Variable ist ein benannter Speicherplatz im Arbeitsspeicher des Computers, der einen Wert eines bestimmten Datentyps enthält. Der Wert einer Variable kann während der Programmausführung verändert werden.

📝 Deklaration und Initialisierung

Deklaration: Festlegen des Namens und Datentyps einer Variable

Initialisierung: Zuweisen eines ersten Wertes

// Nur Deklaration
int alter;

// Deklaration mit Initialisierung
int alter = 17;

// Mehrere Variablen gleichen Typs
int x = 5, y = 10, z = 15;

// Wert ändern
alter = 18; // alter ist jetzt 18
Variablenname = Etikett auf einer Box
Stell dir eine Variable wie eine beschriftete Box vor. Das Etikett (Name) zeigt dir, was drin ist, und der Datentyp bestimmt, was hineinpasst (nur Zahlen, nur Text, etc.).
Regeln für Variablennamen:
  • Beginnen mit Buchstabe, Unterstrich (_) oder Dollarzeichen ($)
  • Keine Leerzeichen oder Sonderzeichen
  • Keine reservierten Schlüsselwörter (int, class, public, etc.)
  • Java unterscheidet Groß-/Kleinschreibung: alter ≠ Alter
  • Konvention: camelCase (z.B. meineVariable)

3. Datentypen in Java

Java unterscheidet zwischen primitiven Datentypen und Referenztypen.

🔢 Primitive Datentypen

Primitive Datentypen speichern einfache Werte direkt im Speicher.

Datentyp Größe Wertebereich Beispiel
byte 8 Bit -128 bis 127 byte b = 100;
short 16 Bit -32.768 bis 32.767 short s = 30000;
int 32 Bit ca. -2 Mrd. bis 2 Mrd. int i = 42;
long 64 Bit sehr große Zahlen long l = 123456789L;
float 32 Bit Kommazahlen (7 Stellen) float f = 3.14f;
double 64 Bit Kommazahlen (15 Stellen) double d = 3.14159;
boolean 1 Bit true oder false boolean b = true;
char 16 Bit Ein Zeichen (Unicode) char c = 'A';

📦 Referenztypen (String)

String ist der wichtigste Referenztyp. Ein String speichert eine Zeichenkette (Text).

String name = "Max Mustermann";
String leer = "";  // Leerer String

// String-Verkettung (Konkatenation)
String vorname = "Max";
String nachname = "Mustermann";
String vollName = vorname + " " + nachname;  // "Max Mustermann"

// String-Länge
int laenge = name.length();  // 14
Merkhilfe für die häufigsten Datentypen:
int für ganze Zahlen, double für Kommazahlen, boolean für wahr/falsch, String für Text.

4. Operatoren

🔢 Arithmetische Operatoren

Für mathematische Berechnungen:

Operator Bedeutung Beispiel Ergebnis
+Addition5 + 38
-Subtraktion5 - 32
*Multiplikation5 * 315
/Division5 / 31 (Integer!)
%Modulo (Rest)5 % 32
Achtung bei der Integer-Division!
5 / 3 = 1 (nicht 1.67!)
Für Kommazahlen: 5.0 / 3 = 1.6666...

⚖️ Vergleichsoperatoren

Vergleichen zwei Werte und geben true oder false zurück:

Operator Bedeutung Beispiel Ergebnis
==gleich5 == 5true
!=ungleich5 != 3true
<kleiner als3 < 5true
>größer als3 > 5false
<=kleiner gleich5 <= 5true
>=größer gleich5 >= 3true

🔗 Logische Operatoren

Verknüpfen boolesche Ausdrücke:

Operator Bedeutung Beispiel Ergebnis
&&UND (AND)true && falsefalse
||ODER (OR)true || falsetrue
!NICHT (NOT)!truefalse
 
int alter = 20;
boolean hatFuehrerschein = true;

// Kombinierte Bedingung
if (alter >= 18 && hatFuehrerschein) {
    System.out.println("Darf Auto fahren");
}

➕ Inkrement und Dekrement

int x = 5;

x++;    // x ist jetzt 6 (x = x + 1)
x--;    // x ist jetzt 5 (x = x - 1)

x += 3;  // x ist jetzt 8 (x = x + 3)
x -= 2;  // x ist jetzt 6 (x = x - 2)
x *= 2;  // x ist jetzt 12 (x = x * 2)

5. Kontrollstrukturen

📖 Was sind Kontrollstrukturen?

Kontrollstrukturen steuern den Ablauf eines Programms. Sie bestimmen, welche Anweisungen unter welchen Bedingungen ausgeführt werden und wie oft bestimmte Codeblöcke wiederholt werden.

5.1 Bedingte Anweisungen (if-else)

🔀 if-Anweisung

Führt Code nur aus, wenn eine Bedingung wahr ist:

int note = 2;

// Einfaches if
if (note <= 4) {
    System.out.println("Bestanden!");
}

// if-else
if (note <= 4) {
    System.out.println("Bestanden!");
} else {
    System.out.println("Nicht bestanden!");
}

// if-else if-else (mehrere Bedingungen)
if (note == 1) {
    System.out.println("Sehr gut!");
} else if (note == 2) {
    System.out.println("Gut!");
} else if (note == 3) {
    System.out.println("Befriedigend!");
} else if (note == 4) {
    System.out.println("Ausreichend!");
} else {
    System.out.println("Nicht bestanden!");
}

5.2 Switch-Case

🎯 switch-Anweisung

Prüft eine Variable gegen mehrere feste Werte:

int tag = 3;
String tagName;

switch (tag) {
    case 1:
        tagName = "Montag";
        break;
    case 2:
        tagName = "Dienstag";
        break;
    case 3:
        tagName = "Mittwoch";
        break;
    case 4:
        tagName = "Donnerstag";
        break;
    case 5:
        tagName = "Freitag";
        break;
    default:
        tagName = "Wochenende";
}
System.out.println(tagName);  // Mittwoch
Vergiss nicht das break!
Ohne break werden alle folgenden Cases auch ausgeführt ("Fall-Through").

6. Schleifen

📖 Was ist eine Schleife?

Eine Schleife ist eine Kontrollstruktur, die einen Codeblock wiederholt ausführt, solange eine bestimmte Bedingung erfüllt ist. Schleifen vermeiden redundanten Code.

6.1 for-Schleife

🔄 for-Schleife (Zählschleife)

Ideal, wenn die Anzahl der Durchläufe bekannt ist:

// Aufbau: for (Start; Bedingung; Veränderung)
for (int i = 0; i < 5; i++) {
    System.out.println("Durchlauf: " + i);
}
// Ausgabe: 0, 1, 2, 3, 4

// Rückwärts zählen
for (int i = 10; i >= 0; i--) {
    System.out.println(i);
}
// Ausgabe: 10, 9, 8, ..., 0

// In 2er-Schritten
for (int i = 0; i <= 10; i += 2) {
    System.out.println(i);
}
// Ausgabe: 0, 2, 4, 6, 8, 10

6.2 while-Schleife

🔄 while-Schleife (Kopfgesteuert)

Prüft die Bedingung VOR jedem Durchlauf:

int zaehler = 0;

while (zaehler < 5) {
    System.out.println("Zähler: " + zaehler);
    zaehler++;
}
// Ausgabe: 0, 1, 2, 3, 4

6.3 do-while-Schleife

🔄 do-while-Schleife (Fußgesteuert)

Prüft die Bedingung NACH jedem Durchlauf (mindestens ein Durchlauf garantiert):

int zaehler = 0;

do {
    System.out.println("Zähler: " + zaehler);
    zaehler++;
} while (zaehler < 5);

// Unterschied: Wird auch ausgeführt, wenn Bedingung anfangs falsch ist
int x = 10;
do {
    System.out.println("Wird einmal ausgegeben!");
} while (x < 5);  // Bedingung ist false, aber Code lief einmal

6.4 break und continue

⏹️ Schleifensteuerung

// break - Schleife komplett beenden
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;  // Beendet bei i=5
    }
    System.out.println(i);
}
// Ausgabe: 0, 1, 2, 3, 4

// continue - Zum nächsten Durchlauf springen
for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;  // Überspringt gerade Zahlen
    }
    System.out.println(i);
}
// Ausgabe: 1, 3, 5, 7, 9

7. Arrays

📖 Was ist ein Array?

Ein Array ist eine Datenstruktur, die mehrere Werte des gleichen Datentyps unter einem gemeinsamen Namen speichert. Der Zugriff erfolgt über einen Index (beginnend bei 0).

📦 Array erstellen und verwenden

// Array deklarieren und erstellen
int[] zahlen = new int[5];  // Array mit 5 Elementen (Standardwert: 0)

// Werte zuweisen
zahlen[0] = 10;
zahlen[1] = 20;
zahlen[2] = 30;
zahlen[3] = 40;
zahlen[4] = 50;

// Direktinitialisierung
int[] noten = {1, 2, 3, 2, 1};

// Zugriff auf Elemente
System.out.println(noten[0]);  // Erstes Element: 1
System.out.println(noten[4]);  // Letztes Element: 1

// Array-Länge
System.out.println(noten.length);  // 5
Index beginnt bei 0!
Ein Array mit 5 Elementen hat die Indizes 0, 1, 2, 3, 4.
Zugriff auf array[5] führt zu einem ArrayIndexOutOfBoundsException!

🔄 Array durchlaufen

int[] zahlen = {10, 20, 30, 40, 50};

// Mit for-Schleife
for (int i = 0; i < zahlen.length; i++) {
    System.out.println("Index " + i + ": " + zahlen[i]);
}

// Mit for-each-Schleife (einfacher zum Lesen)
for (int zahl : zahlen) {
    System.out.println(zahl);
}

// Summe berechnen
int summe = 0;
for (int zahl : zahlen) {
    summe += zahl;
}
System.out.println("Summe: " + summe);  // 150

📊 Mehrdimensionale Arrays

// 2D-Array (Matrix)
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Zugriff: matrix[Zeile][Spalte]
System.out.println(matrix[0][0]);  // 1 (erste Zeile, erste Spalte)
System.out.println(matrix[1][2]);  // 6 (zweite Zeile, dritte Spalte)

// 2D-Array durchlaufen
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

8. Methoden

📖 Was ist eine Methode?

Eine Methode ist ein benannter Codeblock, der eine bestimmte Aufgabe ausführt. Methoden können Parameter entgegennehmen und Werte zurückgeben. Sie ermöglichen die Wiederverwendung von Code und verbessern die Übersichtlichkeit des Programms.

🔧 Aufbau einer Methode

// Methodenaufbau
// [Modifizierer] [Rückgabetyp] [Name]([Parameter]) { [Code] }

// Methode ohne Rückgabe (void)
public static void begruessen() {
    System.out.println("Hallo!");
}

// Methode mit Parameter
public static void begruessen(String name) {
    System.out.println("Hallo, " + name + "!");
}

// Methode mit Rückgabewert
public static int addiere(int a, int b) {
    return a + b;
}

// Methode mit mehreren Parametern und Rückgabe
public static double berechneKreisFlaech(double radius) {
    return 3.14159 * radius * radius;
}

📞 Methodenaufruf

public class MethodenBeispiel {
    public static void main(String[] args) {
        // Methode ohne Parameter aufrufen
        begruessen();
        
        // Methode mit Parameter aufrufen
        begruessen("Max");
        
        // Rückgabewert verwenden
        int ergebnis = addiere(5, 3);
        System.out.println("5 + 3 = " + ergebnis);
        
        // Direkt in Ausgabe
        System.out.println("10 + 7 = " + addiere(10, 7));
    }
    
    public static void begruessen() {
        System.out.println("Hallo!");
    }
    
    public static void begruessen(String name) {
        System.out.println("Hallo, " + name + "!");
    }
    
    public static int addiere(int a, int b) {
        return a + b;
    }
}

🔀 Methodenüberladung (Overloading)

Mehrere Methoden mit gleichem Namen, aber unterschiedlichen Parametern:

// Gleicher Methodenname, verschiedene Parameter
public static int addiere(int a, int b) {
    return a + b;
}

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

public static double addiere(double a, double b) {
    return a + b;
}

// Java wählt automatisch die passende Methode
addiere(5, 3);        // ruft int-Version auf
addiere(5, 3, 2);     // ruft 3-Parameter-Version auf
addiere(5.0, 3.0);    // ruft double-Version auf

📋 Zusammenfassung: Java Grundlagen

  • Variable: Benannter Speicherplatz für Werte eines bestimmten Datentyps
  • Primitive Datentypen: int, double, boolean, char (speichern direkte Werte)
  • Referenztypen: String, Arrays, Objekte (speichern Referenzen)
  • Operatoren: Arithmetisch (+,-,*,/,%), Vergleich (==,!=,<,>), Logisch (&&,||,!)
  • if-else: Bedingte Ausführung von Code
  • switch: Auswahl zwischen mehreren festen Werten
  • for-Schleife: Zählschleife mit bekannter Anzahl Durchläufe
  • while-Schleife: Kopfgesteuerte Schleife (Prüfung vor Durchlauf)
  • do-while-Schleife: Fußgesteuerte Schleife (mindestens ein Durchlauf)
  • Array: Sammlung von Werten gleichen Typs, Index beginnt bei 0
  • Methode: Wiederverwendbarer Codeblock mit optionalen Parametern und Rückgabewert

← Zurück zur Übersicht Weiter zu OOP →