====== Imperative Programmierung mit Java ======

Die **imperative Programmierung** ist ein Programmierparadigma, das sich auf die Beschreibung von **Anweisungen** konzentriert, die der Computer in einer bestimmten Reihenfolge ausführen soll, um ein bestimmtes Ziel zu erreichen. Bei der imperativen Programmierung steht im Vordergrund, *wie* ein Problem gelöst wird. In der Programmiersprache **Java** wird dieses Paradigma häufig verwendet und ist eine Grundlage für die Softwareentwicklung.

----

===== 1. Grundkonzepte der imperativen Programmierung =====

Die imperative Programmierung nutzt verschiedene grundlegende Konzepte:

  * **Anweisungen**: Dies sind die grundlegenden Befehle, die der Computer ausführt.
  * **Variablen**: Speicherorte für Daten, die im Verlauf des Programms verändert werden können.
  * **Kontrollstrukturen**: Diese steuern den Ablauf des Programms und umfassen:
    * **Bedingungen** (`if`, `else`, `switch`)
    * **Schleifen** (`for`, `while`, `do-while`)
  * **Funktionen**: Wiederverwendbare Codeblöcke, die spezifische Aufgaben übernehmen.

----

===== 2. Anweisungen und Variablen =====

In Java werden Variablen deklariert, um Daten zu speichern. Hier ist ein einfaches Beispiel:

<code java>
int a = 5; // Deklaration einer Integer-Variablen
int b = 10; // Deklaration einer weiteren Integer-Variablen
int summe = a + b; // Berechnung der Summe
System.out.println("Die Summe ist: " + summe); // Ausgabe der Summe
</code>

In diesem Beispiel werden zwei Variablen `a` und `b` deklariert und initialisiert. Die dritte Variable `summe` speichert das Ergebnis der Addition von `a` und `b`.

----

===== 3. Kontrollstrukturen =====

Kontrollstrukturen sind entscheidend für die Steuerung des Programmablaufs.

==== 3.1 Bedingungen ====
Bedingungen werden in Java mit `if`, `else if` und `else` implementiert:

<code java>
int zahl = 15;

if (zahl > 10) {
    System.out.println("Die Zahl ist größer als 10");
} else if (zahl == 10) {
    System.out.println("Die Zahl ist gleich 10");
} else {
    System.out.println("Die Zahl ist kleiner als 10");
}
</code>

In diesem Beispiel wird überprüft, ob die Variable `zahl` größer, gleich oder kleiner als 10 ist, und eine entsprechende Nachricht wird ausgegeben.

==== 3.2 Schleifen ====
Schleifen ermöglichen es, Codeblöcke wiederholt auszuführen. Hier sind die zwei häufigsten Schleifen in Java:

**For-Schleife**:
<code java>
for (int i = 0; i < 5; i++) {
    System.out.println("Wert von i: " + i);
}
</code>
Diese Schleife gibt die Werte von `i` von 0 bis 4 aus.

**While-Schleife**:
<code java>
int j = 0;
while (j < 5) {
    System.out.println("Wert von j: " + j);
    j++;
}
</code>
Hier wird die Schleife so lange ausgeführt, wie `j` kleiner als 5 ist.

----

===== 4. Funktionen =====

Funktionen (oder Methoden) sind ein weiterer zentraler Bestandteil der imperativen Programmierung. Sie ermöglichen es, Code zu organisieren und wiederverwendbar zu machen.

Ein Beispiel für eine Funktion, die die Summe von zwei Zahlen berechnet:

<code java>
public static int addiere(int x, int y) {
    return x + y;
}

public static void main(String[] args) {
    int ergebnis = addiere(5, 10);
    System.out.println("Das Ergebnis ist: " + ergebnis);
}
</code>

Hier wird die Funktion `addiere` definiert, die zwei Parameter entgegennimmt und deren Summe zurückgibt. Im `main`-Methodenaufruf wird die Funktion verwendet, um das Ergebnis zu berechnen und auszugeben.

----

===== 5. Beispielanwendung =====

Im Folgenden wird eine einfache Anwendung erstellt, die die Summe der ersten `n` natürlichen Zahlen berechnet:

<code java>
import java.util.Scanner;

public class SummeNatuerlicheZahlen {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Geben Sie eine Zahl n ein: ");
        int n = scanner.nextInt();
        int summe = 0;

        for (int i = 1; i <= n; i++) {
            summe += i; // Addiere i zur Summe
        }

        System.out.println("Die Summe der ersten " + n + " natürlichen Zahlen ist: " + summe);
        scanner.close();
    }
}
</code>

In diesem Beispiel fordert das Programm den Benutzer auf, eine Zahl `n` einzugeben, und berechnet die Summe der ersten `n` natürlichen Zahlen mit einer `for`-Schleife.

----

===== 6. Fazit =====

Die imperative Programmierung ist ein fundamentales Konzept in der Softwareentwicklung und bietet eine klare Struktur zur Lösung von Problemen. Mit Java können Programmierer durch den Einsatz von Anweisungen, Variablen, Kontrollstrukturen und Funktionen effiziente Programme erstellen. 

Für eine tiefere Auseinandersetzung mit spezifischen Themen der imperativen Programmierung, wie zum Beispiel fortgeschrittene Kontrollstrukturen oder die Erstellung komplexerer Funktionen, sind die folgenden Artikel hilfreich:

  * [[schleifen|Schleifen]]
  * [[bedingungen|Bedingungen]]
  * [[methoden|Methoden]]