Initial commit: IHK Ausbildung materials

1-Ausbildungsjahr/LF5-Analyse-Design/LF5-03-Programmierung.md

@@ -0,0 +1,302 @@
+# 5.3 Programmierung
+
+## Algorithmen
+
+### Was ist ein Algorithmus?
+
+> Ein **Algorithmus** ist eine endliche Folge von eindeutigen Anweisungen zur Lösung eines Problems.
+
+### Eigenschaften
+
+```
+Algorithmus-Eigenschaften
+├── Endlichkeit → Endlich viele Schritte
+├── Eindeutigkeit → Jeder Schritt klar definiert
+├── Ausführbarkeit → Jeder Schritt ausführbar
+├── Terminiertheit → Algorithmus endet
+└── Korrektheit → Liefert richtiges Ergebnis
+```
+
+---
+
+## Grundlegende Programmstrukturen
+
+### Sequenz
+
+```
+Anweisungen werden nacheinander ausgeführt
+
+Schritt 1
+   ↓
+Schritt 2
+   ↓
+Schritt 3
+```
+
+### Selektion (Verzweigung)
+
+```
+Wenn-Dann-Sonst
+
+┌───────────────┐
+│ Bed. erfüllt? │
+└───────┬───────┘
+     ╱     ╲
+   Ja     Nein
+     ╲     ╱
+      ▼     ▼
+┌────────┐ ┌────────┐
+│ Block A│ │ Block B│
+└────────┘ └────────┘
+```
+
+### Iteration (Schleife)
+
+```
+Wiederholung
+
+┌───────────────┐
+│  Bedingung    │
+└───────┬───────┘
+     ╱     ╲
+  wahr   falsch
+     ╲     ╱
+      ▼     ▼
+┌─────────┐   ┌──────┐
+│ Block   │──►│ Ende │
+│ ausführen│   └──────┘
+└─────────┘
+```
+
+---
+
+## Datenstrukturen
+
+### Grundlegende Datentypen
+
+| Typ | Beispiel | Speicher |
+|-----|----------|----------|
+| Integer | 42 | 4 Byte |
+| Float | 3.14 | 8 Byte |
+| Boolean | true/false | 1 Byte |
+| Char | 'A' | 1 Byte |
+| String | "Hallo" | variabel |
+
+### Arrays
+
+```
+Array - eindimensional
+[0] [1] [2] [3] [4]
+ 10   20  30   40  50
+
+Zugriff: array[2] → 30
+```
+
+### Listen
+
+```
+Liste - dynamisch
+Liste<String> namen = ["Max", "Anna", "Peter"]
+
+Operationen:
+- add(Element)     → Hinzufügen
+- remove(Index)    → Entfernen
+- get(Index)       → Abrufen
+- size()           → Größe
+```
+
+### Schlüssel-Wert-Paare (Dictionary/Map)
+
+```
+Map - Schlüssel-Wert
+{
+  "Name": "Max",
+  "Alter": 25,
+  "Stadt": "Berlin"
+}
+```
+
+---
+
+## Algorithmen
+
+### Suchen
+
+#### Lineare Suche
+
+```
+Suche in ungeordneter Liste
+Schleife durch alle Elemente
+→ O(n) Zeitkomplexität
+```
+
+#### Binäre Suche
+
+```
+Suche in sortierter Liste
+Teile und Herrsche
+→ O(log n) Zeitkomplexität
+```
+
+### Sortieren
+
+#### Bubble Sort
+
+```
+Vergleiche benachbarte Elemente
+Tausche wenn in falscher Reihenfolge
+
+Beispiel:
+[5, 3, 8, 1] → [3, 5, 1, 8] → [3, 1, 5, 8] → ...
+
+→ O(n²) Zeitkomplexität
+```
+
+#### Quick Sort
+
+```
+Pivot-Element wählen
+Kleine links, große rechts
+Rekursiv wiederholen
+
+→ O(n log n) Durchschnitt
+```
+
+---
+
+## Komplexität
+
+### Big O Notation
+
+| Notation | Name | Beispiel |
+|----------|------|----------|
+| O(1) | Konstant | Array-Zugriff |
+| O(log n) | Logarithmisch | Binäre Suche |
+| O(n) | Linear | Lineare Suche |
+| O(n log n) | Linearithmisch | Quick Sort |
+| O(n²) | Quadratisch | Bubble Sort |
+| O(2^n) | Exponentiell | Brute Force |
+
+---
+
+## Programmiersprachen
+
+### Übersicht
+
+| Sprache | Typ | Einsatz |
+|---------|-----|----------|
+| **Python** | Interpretiert | Data Science, Web |
+| **Java** | Kompiliert | Enterprise |
+| **JavaScript** | Interpretiert | Web, Frontend |
+| **C#** | Kompiliert | Windows, .NET |
+| **C/C++** | Kompiliert | Systemnah |
+
+### Sprachkonzepte
+
+```
+Programmierparadigmen
+├── Imperativ → Anweisungen
+├── Prozedural → Funktionen
+├── Objektorientiert → Klassen/Objekte
+├── Funktional → Funktionen ohne Zustand
+└── Logisch → Regeln und Fakten
+```
+
+---
+
+## Objektorientierte Programmierung (OOP)
+
+### Grundkonzepte
+
+```
+OOP - Prinzipien
+├── Kapselung (Encapsulation)
+├── Vererbung (Inheritance)
+├── Polymorphie
+└── Abstraktion
+```
+
+### Klasse und Objekt
+
+```python
+# Klasse (Bauplan)
+class Auto:
+    # Konstruktor
+    def __init__(self, marke, farbe):
+        self.marke = marke
+        self.farbe = farbe
+        self.geschwindigkeit = 0
+
+    # Methode
+    def beschleunigen(self, wert):
+        self.geschwindigkeit += wert
+
+    def __str__(self):
+        return f"{self.marke}, {self.farbe}"
+
+# Objekt (Instanz)
+mein_auto = Auto("BMW", "rot")
+mein_auto.beschleunigen(50)
+```
+
+### Vererbung
+
+```python
+class Tier:
+    def __init__(self, name):
+        self.name = name
+
+    def essen(self):
+        print("Tier isst")
+
+class Hund(Tier):  # Vererbung
+    def bellen(self):
+        print("Wuff!")
+
+hund = Hund("Bello")
+hund.essen()  # Von Tier geerbt
+hund.bellen() # Eigene Methode
+```
+
+---
+
+## Qualitätskriterien
+
+### Clean Code Prinzipien
+
+```
+Gute Software
+├── Lesbarkeit → Gut verständlich
+├── Wartbarkeit → Einfach zu ändern
+├── Effizienz → Schnell genug
+├── Zuverlässigkeit → Keine Fehler
+└── Sicherheit → Vor Angriffen geschützt
+```
+
+### Namenskonventionen
+
+```
+Variablen: camelCase
+meinName = "Max"
+
+Konstanten: UPPER_CASE
+MAX_ALTER = 100
+
+Funktionen: camelCase
+def holeDaten():
+
+Klassen: PascalCase
+class Benutzer:
+```
+
+---
+
+## Querverweise
+
+- [[LF5-02-Softwaremodellierung|Zurück: Softwaremodellierung]]
+- [[LF5-04-Testverfahren|Nächstes Thema: Testverfahren]]
+- [[LF4-01-Gefahren-Analyse|Sicherheit: Sichere Programmierung]]
+
+---
+
+*Stand: 2024*