303 lines
5.3 KiB
Markdown
303 lines
5.3 KiB
Markdown
# 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*
|