Einführung in die Programmierung

Umfassende Präsentation

Von den Grundlagen bis zur objektorientierten Programmierung

📚 Programmiersprachen & Paradigmen

⚙️ Compiler vs. Interpreter

🔧 C# Grundlagen & Syntax

🎯 Objektorientierte Programmierung

Was ist Programmierung?

Programmierung ist der Prozess der Erstellung von Computerprogrammen durch das Schreiben von Code in einer Programmiersprache.

Grundprinzipien:

🧠 Algorithmus

Schrittweise Anleitung zur Lösung eines Problems

🔍 Logik

Strukturiertes Denken und Problemlösung

📝 Syntax

Regeln und Struktur der Programmiersprache

🎯 Ziel

Computer sagen, was sie tun sollen

Entwicklung der Programmiersprachen

1. Generation (1940er-1950er): Maschinensprache

• Binärcode (0 und 1) • Direkte Hardware-Kommunikation • Sehr schwer zu verstehen

2. Generation (1950er): Assemblersprachen

• Mnemonische Codes (ADD, MOV, JMP) • Immer noch hardwarenah

3. Generation (1960er-heute): Höhere Programmiersprachen

• FORTRAN (1957), COBOL (1959), C (1972), Pascal (1970)

4. Generation: Domänenspezifische Sprachen

• SQL (Datenbanken), HTML (Web), MATLAB (Mathematik)

5. Generation: KI und natürliche Sprachen

• Prolog (Logik), Lisp (KI), moderne AI-Tools

Prozedurale Programmierung

Charakteristika:

Programme bestehen aus Funktionen/Prozeduren
Top-Down-Ansatz
Daten und Funktionen sind getrennt
Sequenzielle Abarbeitung

Beispielsprachen:

C, Pascal, FORTRAN

✅ Vorteile:

Einfach zu verstehen
Klare Struktur
Gut für mathematische Probleme

❌ Nachteile:

Schwierig bei komplexen Systemen
Daten nicht geschützt
Begrenzte Code-Wiederverwendung

Objektorientierte Programmierung (OOP)

🏗️ Grundprinzipien:

🔒 Kapselung

Daten und Methoden in Objekten vereint

🧬 Vererbung

Eigenschaften von übergeordneten Klassen übernehmen

🎭 Polymorphie

Gleiche Schnittstelle, verschiedene Implementierungen

🎯 Abstraktion

Komplexität verbergen

Beispielsprachen:

Java, C#, C++, Python

✅ Vorteile:

Code-Wiederverwendbarkeit
Bessere Wartbarkeit
Modularität
Näher zur realen Welt

Compiler vs. Interpreter

Aspekt

🔧 Compiler

⚡ Interpreter

Funktionsweise

Übersetzt gesamten Code vor Ausführung

Übersetzt und führt Code zeilenweise aus

Ausgabe

Erzeugt ausführbare Datei

Keine separate Datei

Geschwindigkeit

Schnelle Ausführung

Langsamere Ausführung

Entwicklung

Längere Entwicklungszeit

Schnelle Entwicklung

Beispiele

C, C++, Go, Rust

Python, JavaScript, Ruby

🔄 Hybride Ansätze:

Just-In-Time (JIT) Compilation: Java (JVM), C# (.NET)

Typisierung in Programmiersprachen

💪 Stark typisierte Sprachen

Eigenschaften:

Strenge Typprüfung
Explizite Typdeklaration
Fehler zur Compile-Zeit
Weniger Laufzeitfehler

✅ Vorteile:

Frühe Fehlererkennung
Bessere Performance
Klarere Dokumentation

Beispiele: Java, C#, C++, TypeScript

🌊 Dynamisch typisierte Sprachen

Eigenschaften:

Typen zur Laufzeit bestimmt
Automatische Typkonvertierung
Flexiblere Programmierung

✅ Vorteile:

Schnellere Entwicklung
Weniger Code
Mehr Flexibilität

❌ Nachteile:

Laufzeitfehler möglich
Schwieriger zu debuggen

Beispiele: Python, JavaScript, Ruby

Grundlegende Datentypen

🔢 Primitive Datentypen

Ganze Zahlen (Integer):

int: -2,147,483,648 bis 2,147,483,647
long: größerer Wertebereich
short: kleinerer Wertebereich

Fließkommazahlen:

float: einfache Genauigkeit
double: doppelte Genauigkeit

Zeichen und Text:

char: einzelnes Zeichen
string: Zeichenketten

Boolesche Werte:

bool: true oder false

📦 Zusammengesetzte Datentypen

Arrays: Sammlung gleicher Typen
Listen: Dynamische Sammlungen
Klassen: Benutzerdefinierte Typen

C# - Variablen deklarieren und initialisieren

// Deklaration
int alter;
string name;

// Initialisierung
alter = 25;
name = "Max Mustermann";

// Deklaration und Initialisierung
int punkte = 100;
double gehalt = 3500.50;
bool istAktiv = true;
char note = 'A';

// Implizite Typisierung
var stadt = "Berlin";  // automatisch als string erkannt
            

💡 Wichtige Punkte:

Variablen müssen vor Verwendung deklariert werden
var für automatische Typerkennung
Aussagekräftige Namen verwenden
CamelCase-Konvention befolgen

C# - Grundlegende Anweisungen

// Ausgabe
Console.WriteLine("Hallo Welt!");
Console.Write("Text ohne Zeilenumbruch");

// Eingabe
string eingabe = Console.ReadLine();

// Berechnungen
int summe = 10 + 20;
int produkt = 5 * 4;
double division = 10.0 / 3.0;

// Zuweisungen
int x = 5;
x += 3;  // x = x + 3
x--;     // x = x - 1

// Bedingungen
if (alter >= 18)
{
    Console.WriteLine("Volljährig");
}
else
{
    Console.WriteLine("Minderjährig");
}
            

C# - Schleifen

🔄 for-Schleife

for (int i = 0; i < 10; i++)
{
    Console.WriteLine($"Durchlauf {i}");
}
                    

⚡ while-Schleife

int counter = 0;
while (counter < 5)
{
    Console.WriteLine($"Counter: {counter}");
    counter++;
}
                    

📋 foreach-Schleife

string[] namen = {"Anna", "Bob", "Clara"};
foreach (string name in namen)
{
    Console.WriteLine($"Name: {name}");
}
                    

🔁 do-while-Schleife

int zahl;
do
{
    Console.Write("Geben Sie eine Zahl ein: ");
    zahl = int.Parse(Console.ReadLine());
} while (zahl < 1 || zahl > 100);
                    

OOP - Klassen und Objekte

// Klassendefinition
public class Person
{
    // Eigenschaften (Properties)
    public string Name { get; set; }
    public int Alter { get; set; }
    
    // Konstruktor
    public Person(string name, int alter)
    {
        Name = name;
        Alter = alter;
    }
    
    // Methode
    public void Vorstellen()
    {
        Console.WriteLine($"Hallo, ich bin {Name} und {Alter} Jahre alt.");
    }
}

// Objekterstellung und Verwendung
Person person1 = new Person("Anna", 25);
person1.Vorstellen();
            

OOP - Vererbung

// Basisklasse
public class Tier
{
    public string Name { get; set; }
    public int Alter { get; set; }
    
    public virtual void Laut()
    {
        Console.WriteLine("Das Tier macht ein Geräusch");
    }
}

// Abgeleitete Klasse
public class Hund : Tier
{
    public string Rasse { get; set; }
    
    public override void Laut()
    {
        Console.WriteLine("Wau wau!");
    }
    
    public void Apportieren()
    {
        Console.WriteLine($"{Name} apportiert den Ball");
    }
}
            

🧬 Vererbung ermöglicht die Wiederverwendung von Code und schafft hierarchische Beziehungen zwischen Klassen.

OOP - Polymorphie und Überladung

🎭 Polymorphie

// Polymorphie durch Vererbung
Tier[] tiere = {
    new Hund() { Name = "Bello" },
    new Katze() { Name = "Mimi" },
    new Vogel() { Name = "Tweety" }
};

foreach (Tier tier in tiere)
{
    tier.Laut(); // Jedes Tier macht seinen spezifischen Laut
}
                    

⚙️ Überladung (Overloading)

public class Rechner
{
    // Methodenüberladung
    public int Addieren(int a, int b)
    {
        return a + b;
    }
    
    public double Addieren(double a, double b)
    {
        return a + b;
    }
    
    public int Addieren(int a, int b, int c)
    {
        return a + b + c;
    }
}
                    

Zusammenfassung & Ausblick

🎯 Was haben wir gelernt?

📚 Entwicklung der Programmiersprachen
⚙️ Unterschied zwischen Compiler und Interpreter
🔧 C# Grundlagen und Syntax
🏗️ Objektorientierte Programmierung
🔒 Kapselung, Vererbung, Polymorphie

🚀 Nächste Schritte:

Praktische Übungen mit C#
Projektbasiertes Lernen
Weitere Sprachen erkunden
Spezielle Bereiche vertiefen

💡 Best Practices:

Aussagekräftige Namen verwenden
Code kommentieren
Konsistente Formatierung
Fehlerbehandlung implementieren
Regelmäßig testen

🎓 Erfolg in der Programmierung:

Die Beherrschung der Grundprinzipien bildet das Fundament für erfolgreiches Programmieren. Von einfachen Variablen bis zu komplexen OOP-Konzepten - jeder Schritt baut auf dem vorherigen auf.