Kapitel 10: Objektorientierte Programmierung (OOP) Grundlagen

🎯 Lernziele

• Was ist OOP? Was sind Klassen und Objekte?
• Klassen definieren (Attribute + Methoden)
• Objekte erstellen und verwenden
• Konstruktoren
• this Schlüsselwort
• Kapselung (Encapsulation) Einstieg

10.1 Was ist OOP? Was sind Klassen und Objekte?

🌍 OOP = Nachahmung der realen Welt

Bei der objektorientierten Programmierung organisieren wir Code in Objekte (Dinge aus der realen Welt).

🏗️ Klasse vs. Objekt

Begriff	Erklärung	Beispiel
Klasse (Class)	Bauplan / Vorlage	"Bauplan für Auto"
Objekt (Object/Instance)	Konkretes Exemplar	"Mein rotes Auto"

→ Klasse = Bauplan, Objekt = Das gebaute Auto!

📋 Beispiel aus dem Alltag

Klasse: Mensch
  ├── Attribute: Name, Alter, Geschlecht
  └── Methoden: Essen(), Schlafen(), Sprechen()

Objekt 1: Max
  ├── Name = "Max"
  ├── Alter = 25
  └── Geschlecht = "Männlich"

Objekt 2: Anna
  ├── Name = "Anna"
  ├── Alter = 30
  └── Geschlecht = "Weiblich"

10.2 Klassen definieren (Attribute + Methoden)

📝 Syntax

class KlassenName {
    // 1. Attribute (Eigenschaften)
    datentyp attributName1;
    datentyp attributName2;
    
    // 2. Methoden (Verhalten)
    rückgabetyp methodeName() {
        // Code
    }
}

📋 Beispiel: Mensch Klasse

class Mensch {
    // Attribute
    String name;
    int alter;
    String geschlecht;
    
    // Methoden
    void sprechen() {
        System.out.println(name + " sagt: Hallo!");
    }
    
    void altern() {
        alter++;
        System.out.println(name + " ist jetzt " + alter + " Jahre alt.");
    }
}

10.3 Objekte erstellen und verwenden

🔧 Objekt erstellen (mit new)

KlassenName objektName = new KlassenName();

📋 Beispiel: Objekte erstellen und verwenden

public class OOPBeispiel {
    public static void main(String[] args) {
        // Objekt 1 erstellen
        Mensch mensch1 = new Mensch();
        mensch1.name = "Max";
        mensch1.alter = 25;
        mensch1.geschlecht = "Männlich";
        
        // Objekt 2 erstellen
        Mensch mensch2 = new Mensch();
        mensch2.name = "Anna";
        mensch2.alter = 30;
        mensch2.geschlecht = "Weiblich";
        
        // Methoden aufrufen
        mensch1.sprechen();  // Max sagt: Hallo!
        mensch2.sprechen();  // Anna sagt: Hallo!
        
        mensch1.altern();  // Max ist jetzt 26 Jahre alt.
    }
}

🔍 Wichtig: Punktoperator (.)

objekt.name  // Attribut zugreifen/ändern
objekt.methode()  // Methode aufrufen

10.4 Konstruktoren (Constructors)

🏗️ Was ist ein Konstruktor?

Konstruktor = Spezielle Methode, die automatisch aufgerufen wird, wenn ein Objekt erstellt wird.

Zweck: Objekt initialisieren (Attribute direkt beim Erstellen setzen).

📝 Syntax

class KlassenName {
    // Konstruktor (gleicher Name wie Klasse, kein Rückgabetyp!)
    KlassenName(parameter) {
        // Initialisierung
    }
}

📋 Beispiel: Konstruktor verwenden

class Mensch {
    String name;
    int alter;
    
    // Konstruktor
    Mensch(String n, int a) {
        name = n;
        alter = a;
    }
    
    void vorstellen() {
        System.out.println("Ich heiße " + name + ", bin " + alter + " Jahre alt.");
    }
}

public class KonstruktorBeispiel {
    public static void main(String[] args) {
        // Objekt mit Konstruktor erstellen
        Mensch m1 = new Mensch("Max", 25);
        Mensch m2 = new Mensch("Anna", 30);
        
        m1.vorstellen();  // Ich heiße Max, bin 25 Jahre alt.
        m2.vorstellen();  // Ich heiße Anna, bin 30 Jahre alt.
    }
}

🔍 Standard-Konstruktor (Default Constructor)

Wenn du keinen Konstruktor definierst, erstellt Java automatisch einen leeren Konstruktor:

Mensch m = new Mensch();  // Standard-Konstruktor (ohne Parameter)

10.5 this Schlüsselwort

🔤 Was ist this?

this = Referenz auf das aktuelle Objekt.

Verwendung:

1. Attribut vs. Parameter (gleicher Name)
2. Konstruktor ruft anderen Konstruktor auf (selten)

📋 Beispiel: this verwenden

class Mensch {
    String name;
    int alter;
    
    // Konstruktor mit this
    Mensch(String name, int alter) {
        this.name = name;    // this.name = Attribut; name = Parameter
        this.alter = alter;
    }
}

→ this verhindert Namenskonflikte!

10.6 Kapselung (Encapsulation) Einstieg

🔒 Was ist Kapselung?

Kapselung = Attribute privat machen (private) und nur über öffentliche Methoden (getter/setter) zugreifen.

Vorteile:

• ✅ Datenschutz (Attribute können nicht direkt geändert werden)
• ✅ Validierung (über setter überprüfen)

📋 Beispiel: Kapselung

class Mensch {
    // Privat (von außen nicht zugreifbar!)
    private String name;
    private int alter;
    
    // Öffentliche getter (lesen)
    public String getName() {
        return name;
    }
    
    // Öffentliche setter (schreiben + validieren)
    public void setName(String name) {
        this.name = name;
    }
    
    public void setAlter(int alter) {
        if (alter >= 0 && alter <= 150) {  // Validierung!
            this.alter = alter;
        } else {
            System.out.println("Ungültiges Alter!");
        }
    }
    
    public int getAlter() {
        return alter;
    }
}

public class KapselungBeispiel {
    public static void main(String[] args) {
        Mensch m = new Mensch();
        
        // Über setter setzen
        m.setName("Max");
        m.setAlter(25);
        
        // Über getter lesen
        System.out.println("Name: " + m.getName());  // Max
        System.out.println("Alter: " + m.getAlter());  // 25
        
        // Ungültiges Alter (wird abgewiesen!)
        m.setAlter(200);  // Ungültiges Alter!
    }
}

📝 Zusammenfassung

In diesem Kapitel hast du gelernt:

• ✅ OOP = Code in Objekte organisieren
• ✅ Klasse = Bauplan, Objekt = Instanz
• ✅ Klassen definieren (Attribute + Methoden)
• ✅ Objekte erstellen (new) und verwenden (.)
• ✅ Konstruktoren (für Initialisierung)
• ✅ this Schlüsselwort (aktuelles Objekt)
• ✅ Kapselung (private + getter/setter)

💡 Merksatz für Anfänger

"Klasse = Bauplan, Objekt = Das gebaute Auto. Konstruktor = Automatische Initialisierung beim Erstellen!"

🎯 Nächste Schritte

Im nächsten Kapitel lernst du:

• OOP 3 Säulen (Kapitel 11)
• Kapselung (Encapsulation) → Vertiefung
• Vererbung (Inheritance)
• Polymorphismus (Polymorphism)

Bereit für die 3 Säulen der OOP? Los geht's! 🚀

---

📚 Weiterführende Links:

• Oracle Java Tutorials - OOP
• Java Encapsulation

💬 Fragen?
Hinterlassen Sie einen Kommentar!