Java Befehle übersicht Pdf

int a = 10;
int b = 5;

int summe = a + b; // summe = 15
int differenz = a - b; // differenz = 5
int produkt = a * b; // produkt = 50
int quotient = a / b; // quotient = 2
int rest = a % b; // rest = 0

Vergleichsoperatoren

Vergleichsoperatoren werden verwendet, um Werte zu vergleichen und einen booleschen Wert (true oder false) zurückzugeben.

• == (Gleichheit)
• != (Ungleichheit)
• > (Größer als)
• < (Kleiner als)
• >= (Größer oder gleich)
• <= (Kleiner oder gleich)

int x = 5;
int y = 10;

boolean istGleich = (x == y); // istGleich = false
boolean istUngleich = (x != y); // istUngleich = true
boolean istGroesser = (x > y); // istGroesser = false
boolean istKleiner = (x < y); // istKleiner = true

Logische Operatoren

Logische Operatoren werden verwendet, um mehrere boolesche Ausdrücke zu kombinieren.

• && (Logisches UND) - Beide Ausdrücke müssen true sein, damit das Ergebnis true ist.
• || (Logisches ODER) - Mindestens einer der Ausdrücke muss true sein, damit das Ergebnis true ist.
• ! (Logisches NICHT) - Negiert den Ausdruck. Wenn der Ausdruck true ist, wird er zu false, und umgekehrt.

boolean a = true;
boolean b = false;

boolean und = (a && b); // und = false
boolean oder = (a || b); // oder = true
boolean nichtA = !a; // nichtA = false

Kontrollstrukturen

Kontrollstrukturen ermöglichen es uns, den Ablauf unseres Programms zu steuern. Sie bestimmen, welche Codeblöcke ausgeführt werden und in welcher Reihenfolge.

if-Anweisung

Die if-Anweisung ermöglicht es uns, Code nur dann auszuführen, wenn eine bestimmte Bedingung erfüllt ist.

int alter = 18;

if (alter >= 18) {
    System.out.println("Du bist volljährig.");
}

Wir können auch einen else-Block hinzufügen, der ausgeführt wird, wenn die Bedingung nicht erfüllt ist.

int alter = 16;

if (alter >= 18) {
    System.out.println("Du bist volljährig.");
} else {
    System.out.println("Du bist noch nicht volljährig.");
}

Zusätzlich können wir else if verwenden, um mehrere Bedingungen zu überprüfen.

int punkte = 75;

if (punkte >= 90) {
    System.out.println("Sehr gut!");
} else if (punkte >= 80) {
    System.out.println("Gut!");
} else if (punkte >= 70) {
    System.out.println("Befriedigend.");
} else {
    System.out.println("Nicht bestanden.");
}

switch-Anweisung

Die switch-Anweisung ermöglicht es uns, basierend auf dem Wert einer Variable verschiedene Codeblöcke auszuführen. Sie ist besonders nützlich, wenn wir viele if-else if-Bedingungen haben.

int tag = 3;

switch (tag) {
    case 1:
        System.out.println("Montag");
        break;
    case 2:
        System.out.println("Dienstag");
        break;
    case 3:
        System.out.println("Mittwoch");
        break;
    default:
        System.out.println("Ungültiger Tag");
}

Wichtig: Die break-Anweisung ist wichtig, um zu verhindern, dass der Code in den nächsten case-Block übergeht. Wenn wir break vergessen, wird der Code weiterhin ausgeführt, bis er auf ein break oder das Ende der switch-Anweisung trifft (sog. "Fall-through").

Schleifen

Schleifen ermöglichen es uns, Codeblöcke wiederholt auszuführen. Java bietet verschiedene Arten von Schleifen:

for-Schleife

Die for-Schleife wird verwendet, wenn wir wissen, wie oft ein Codeblock wiederholt werden soll.

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

Die for-Schleife besteht aus drei Teilen:

1. Initialisierung: Hier wird die Zählvariable (i in diesem Fall) initialisiert.
2. Bedingung: Die Schleife wird solange ausgeführt, wie diese Bedingung erfüllt ist (i < 10).
3. Inkrement/Dekrement: Hier wird die Zählvariable nach jedem Durchlauf erhöht oder verringert (i++).

while-Schleife

Die while-Schleife wird verwendet, wenn wir nicht wissen, wie oft ein Codeblock wiederholt werden soll. Die Schleife wird solange ausgeführt, wie eine bestimmte Bedingung erfüllt ist.

int zahl = 0;

while (zahl < 5) {
    System.out.println("Zahl: " + zahl);
    zahl++;
}

Achtung: Wenn die Bedingung der while-Schleife immer true ist, entsteht eine Endlosschleife. Das Programm wird dann nie beendet!

do-while-Schleife

Die do-while-Schleife ist ähnlich wie die while-Schleife, aber sie garantiert, dass der Codeblock mindestens einmal ausgeführt wird. Die Bedingung wird am Ende des Schleifenkörpers überprüft.

int zahl = 0;

do {
    System.out.println("Zahl: " + zahl);
    zahl++;
} while (zahl < 5);

Methoden

Methoden sind wiederverwendbare Codeblöcke, die eine bestimmte Aufgabe ausführen. Sie helfen uns, unseren Code zu strukturieren und zu organisieren. Betrachten wir eine Methode als eine kleine Maschine, die eine spezifische Aufgabe erledigt, wenn wir sie "starten".

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

public static void main(String[] args) {
    int ergebnis = addiere(5, 3);
    System.out.println("Ergebnis: " + ergebnis); // Gibt "Ergebnis: 8" aus
}

Hier haben wir eine Methode namens addiere, die zwei int-Werte als Parameter entgegennimmt und deren Summe zurückgibt. Die main-Methode ist der Einstiegspunkt unseres Programms. Hier rufen wir die addiere-Methode auf und geben das Ergebnis aus.

Vorteile von Methoden:

• Wiederverwendbarkeit: Wir können eine Methode mehrmals in unserem Programm verwenden, ohne den Code wiederholen zu müssen.
• Strukturierung: Methoden helfen uns, unseren Code in kleinere, übersichtlichere Einheiten zu unterteilen.
• Lesbarkeit: Methoden machen unseren Code leichter lesbar und verständlich.

Objektorientierung (Grundlagen)

Java ist eine objektorientierte Programmiersprache. Das bedeutet, dass wir unsere Programme um Objekte herum aufbauen. Ein Objekt ist eine Instanz einer Klasse. Stell dir eine Klasse als einen Bauplan für ein Objekt vor. Sie definiert die Eigenschaften (Attribute) und das Verhalten (Methoden) des Objekts.

class Auto {
    String marke;
    String modell;
    int baujahr;

    void fahren() {
        System.out.println("Das Auto fährt...");
    }
}

public class Main {
    public static void main(String[] args) {
        Auto meinAuto = new Auto();
        meinAuto.marke = "BMW";
        meinAuto.modell = "X5";
        meinAuto.baujahr = 2020;

        System.out.println("Marke: " + meinAuto.marke);
        meinAuto.fahren();
    }
}

Hier haben wir eine Klasse namens Auto, die die Eigenschaften marke, modell und baujahr sowie die Methode fahren definiert. In der main-Methode erstellen wir ein Objekt (eine Instanz) der Klasse Auto namens meinAuto und weisen ihm Werte zu. Dann rufen wir die Methode fahren auf.

Natürlich ist die Objektorientierung ein komplexes Thema, aber dies ist ein grundlegendes Beispiel, um dir einen ersten Eindruck zu vermitteln.

Fehlerbehandlung (Try-Catch)

Fehlerbehandlung ist ein wichtiger Aspekt der Programmierung. Sie ermöglicht es uns, Fehler, die während der Ausführung unseres Programms auftreten können, abzufangen und zu behandeln, anstatt dass das Programm abstürzt.

In Java verwenden wir dafür try-catch-Blöcke.

try {
    // Code, der potenziell einen Fehler verursachen kann
    int a = 10;
    int b = 0;
    int ergebnis = a / b; // Dies führt zu einer ArithmeticException
    System.out.println("Ergebnis: " + ergebnis);
} catch (ArithmeticException e) {
    // Code, der ausgeführt wird, wenn ein ArithmeticException auftritt
    System.out.println("Fehler: Division durch Null!");
} catch (Exception e) {
    // Code, der ausgeführt wird, wenn ein anderer Fehler auftritt
    System.out.println("Ein unerwarteter Fehler ist aufgetreten: " + e.getMessage());
} finally {
    // Code, der in jedem Fall ausgeführt wird, unabhängig davon, ob ein Fehler aufgetreten ist oder nicht
    System.out.println("Dieser Code wird immer ausgeführt.");
}

Der try-Block enthält den Code, der potenziell einen Fehler verursachen kann. Wenn ein Fehler auftritt, wird der entsprechende catch-Block ausgeführt. Der finally-Block wird immer ausgeführt, unabhängig davon, ob ein Fehler aufgetreten ist oder nicht. Er wird oft verwendet, um Ressourcen freizugeben oder Aufräumarbeiten durchzuführen.