OOP Grundlagen: Klasse, Objekt, Instanz, Attribute & Methoden

Dieser Beitrag ist eine Begriffserklärung zu den Grundlagen der objektorientierten Programmierung – inklusive Klasse, Objekt, Attributen und Methoden.

In a Nutshell

OOP ist ein Programmierparadigma, das Software aus wiederverwendbaren, klar strukturierten “Bausteinen” – den Objekten – zusammensetzt. Eine Klasse ist der Bauplan, ein Objekt die konkrete Ausprägung.

Kompakte Fachbeschreibung

Objektorientierte Programmierung (OOP) ist ein Paradigma, das reale Weltobjekte durch Software-Objekte nachbildet. Der zentrale Unterschied zwischen Klasse und Objekt ist fundamental:

Klasse (Bauplan):

• Abstrakte Vorlage oder Schablone
• Definiert Attribute (Eigenschaften) und Methoden (Fähigkeiten)
• Existiert nur einmal im Code
• Beispiel: Klasse Auto definiert Eigenschaften wie Farbe und Methoden wie bremsen()

Objekt/Instanz (konkretes Ding):

• Konkrete Ausprägung einer Klasse
• Wird zur Laufzeit erstellt (new-Operator)
• Hat spezifische Attributwerte
• Beispiel: Objekt meinGolf mit Farbe=“blau”, Leistung=150PS

Kernkonzepte:

• Kapselung: Daten und Methoden werden zu Einheit gebündelt
• Wiederverwendbarkeit: Klassen können mehrfach instanziiert werden
• Strukturierung: Klare Trennung von Verantwortlichkeiten
• Abstraktion: Komplexe Realität auf relevante Eigenschaften reduziert

Prüfungsrelevante Stichpunkte

• Klasse vs Objekt: Abstrakter Bauplan vs konkrete Instanz
• Attribute: Eigenschaften/Daten eines Objekts
• Methoden: Verhalten/Fähigkeiten eines Objekts
• Instanziierung: Erstellung von Objekten aus Klassen
• Konstruktor: Spezielle Methode zur Objekterstellung
• Kapselung: Daten und Methoden zusammenfassen
• IHK-relevant: Fundamentales Verständnis für Softwareentwicklung
• Praxis: Wiederverwendung und Wartbarkeit von Code

Kernkomponenten

1. Klasse: Definition mit Attributen und Methoden
2. Objekt: Konkrete Instanz einer Klasse
3. Attribute: Eigenschaften/Daten eines Objekts
4. Methoden: Verhalten/Funktionen eines Objekts
5. Konstruktor: Initialisierungsmethode für neue Objekte
6. Instanzvariablen: Objektspezifische Daten
7. Klassenmethoden: Für die Klasse gültige Methoden
8. Getter/Setter: Zugriffsmethoden für Attribute

Praxisbeispiele

1. Einfache Klasse in Java

// Klasse als Bauplan
public class Auto {
    // Attribute (Eigenschaften)
    private String farbe;
    private int anzahlTueren;
    private int leistungInPS;
    private int aktuelleGeschwindigkeit;
    
    // Konstruktor zur Objekterstellung
    public Auto(String farbe, int anzahlTueren, int leistungInPS) {
        this.farbe = farbe;
        this.anzahlTueren = anzahlTueren;
        this.leistungInPS = leistungInPS;
        this.aktuelleGeschwindigkeit = 0;
    }
    
    // Methoden (Verhalten)
    public void beschleunigen(int kmh) {
        this.aktuelleGeschwindigkeit += kmh;
        System.out.println("Auto beschleunigt auf " + this.aktuelleGeschwindigkeit + " km/h");
    }
    
    public void bremsen(int kmh) {
        if (this.aktuelleGeschwindigkeit >= kmh) {
            this.aktuelleGeschwindigkeit -= kmh;
            System.out.println("Auto bremst auf " + this.aktuelleGeschwindigkeit + " km/h");
        } else {
            System.out.println("Kann nicht unter 0 km/h bremsen");
        }
    }
    
    // Getter-Methoden für den Zugriff auf Attribute
    public String getFarbe() {
        return farbe;
    }
    
    public int getAktuelleGeschwindigkeit() {
        return aktuelleGeschwindigkeit;
    }
    
    public void anzeigen() {
        System.out.println("Auto - Farbe: " + farbe + 
                          ", Türen: " + anzahlTueren + 
                          ", Leistung: " + leistungInPS + " PS" +
                          ", Geschwindigkeit: " + aktuelleGeschwindigkeit + " km/h");
    }
}

// Verwendung der Klasse
public class Garage {
    public static void main(String[] args) {
        // Objekte (Instanzen) erstellen
        Auto meinGolf = new Auto("blau", 5, 150);
        Auto deinA3 = new Auto("schwarz", 3, 120);
        Auto companyAuto = new Auto("silber", 4, 200);
        
        // Objekte verwenden
        meinGolf.anzeigen();
        meinGolf.beschleunigen(50);
        meinGolf.beschleunigen(30);
        meinGolf.bremsen(20);
        
        System.out.println("---");
        
        deinA3.anzeigen();
        deinA3.beschleunigen(80);
        
        System.out.println("---");
        
        companyAuto.anzeigen();
        companyAuto.beschleunigen(100);
    }
}

2. Klasse in Python

# Klasse als Bauplan
class Auto:
    # Klassenattribut (gilt für alle Autos)
    anzahl_autos = 0
    
    # Konstruktor
    def __init__(self, farbe, anzahl_tueren, leistung_in_ps):
        # Instanzattribute (objektspezifisch)
        self.farbe = farbe
        self.anzahl_tueren = anzahl_tueren
        self.leistung_in_ps = leistung_in_ps
        self.aktuelle_geschwindigkeit = 0
        
        # Klassenattribut erhöhen
        Auto.anzahl_autos += 1
    
    # Methoden
    def beschleunigen(self, kmh):
        self.aktuelle_geschwindigkeit += kmh
        print(f"Auto beschleunigt auf {self.aktuelle_geschwindigkeit} km/h")
    
    def bremsen(self, kmh):
        if self.aktuelle_geschwindigkeit >= kmh:
            self.aktuelle_geschwindigkeit -= kmh
            print(f"Auto bremst auf {self.aktuelle_geschwindigkeit} km/h")
        else:
            print("Kann nicht unter 0 km/h bremsen")
    
    def anzeigen(self):
        print(f"Auto - Farbe: {self.farbe}, Türen: {self.anzahl_tueren}, " +
              f"Leistung: {self.leistung_in_ps} PS, " +
              f"Geschwindigkeit: {self.aktuelle_geschwindigkeit} km/h")
    
    # Klassenmethode
    @classmethod
    def get_anzahl_autos(cls):
        return cls.anzahl_autos

# Verwendung der Klasse
def garage_demo():
    # Objekte (Instanzen) erstellen
    mein_golf = Auto("blau", 5, 150)
    dein_a3 = Auto("schwarz", 3, 120)
    company_auto = Auto("silber", 4, 200)
    
    # Objekte verwenden
    mein_golf.anzeigen()
    mein_golf.beschleunigen(50)
    mein_golf.beschleunigen(30)
    mein_golf.bremsen(20)
    
    print("---")
    
    dein_a3.anzeigen()
    dein_a3.beschleunigen(80)
    
    print("---")
    
    company_auto.anzeigen()
    company_auto.beschleunigen(100)
    
    print(f"Anzahl erstellter Autos: {Auto.get_anzahl_autos()}")

if __name__ == "__main__":
    garage_demo()

3. Klasse in C#

using System;

// Klasse als Bauplan
public class Auto
{
    // Attribute (Eigenschaften)
    private string farbe;
    private int anzahlTueren;
    private int leistungInPS;
    private int aktuelleGeschwindigkeit;
    
    // Statische Eigenschaft für alle Autos
    public static int AnzahlAutos { get; private set; }
    
    // Konstruktor
    public Auto(string farbe, int anzahlTueren, int leistungInPS)
    {
        this.farbe = farbe;
        this.anzahlTueren = anzahlTueren;
        this.leistungInPS = leistungInPS;
        this.aktuelleGeschwindigkeit = 0;
        AnzahlAutos++;
    }
    
    // Methoden
    public void Beschleunigen(int kmh)
    {
        this.aktuelleGeschwindigkeit += kmh;
        Console.WriteLine($"Auto beschleunigt auf {this.aktuelleGeschwindigkeit} km/h");
    }
    
    public void Bremsen(int kmh)
    {
        if (this.aktuelleGeschwindigkeit >= kmh)
        {
            this.aktuelleGeschwindigkeit -= kmh;
            Console.WriteLine($"Auto bremst auf {this.aktuelleGeschwindigkeit} km/h");
        }
        else
        {
            Console.WriteLine("Kann nicht unter 0 km/h bremsen");
        }
    }
    
    // Properties für den Zugriff auf Attribute
    public string Farbe => farbe;
    public int AktuelleGeschwindigkeit => aktuelleGeschwindigkeit;
    
    public void Anzeigen()
    {
        Console.WriteLine($"Auto - Farbe: {farbe}, Türen: {anzahlTueren}, " +
                         $"Leistung: {leistungInPS} PS, " +
                         $"Geschwindigkeit: {aktuelleGeschwindigkeit} km/h");
    }
}

// Verwendung der Klasse
public class Garage
{
    public static void Main(string[] args)
    {
        // Objekte (Instanzen) erstellen
        Auto meinGolf = new Auto("blau", 5, 150);
        Auto deinA3 = new Auto("schwarz", 3, 120);
        Auto companyAuto = new Auto("silber", 4, 200);
        
        // Objekte verwenden
        meinGolf.Anzeigen();
        meinGolf.Beschleunigen(50);
        meinGolf.Beschleunigen(30);
        meinGolf.Bremsen(20);
        
        Console.WriteLine("---");
        
        deinA3.Anzeigen();
        deinA3.Beschleunigen(80);
        
        Console.WriteLine("---");
        
        companyAuto.Anzeigen();
        companyAuto.Beschleunigen(100);
        
        Console.WriteLine($"Anzahl erstellter Autos: {Auto.AnzahlAutos}");
    }
}

Konzepte im Detail

Konstruktoren

// Überladene Konstruktoren in Java
public class Auto {
    private String farbe;
    private int leistung;
    
    // Standard-Konstruktor
    public Auto() {
        this.farbe = "schwarz";
        this.leistung = 100;
    }
    
    // Konstruktor mit Parametern
    public Auto(String farbe, int leistung) {
        this.farbe = farbe;
        this.leistung = leistung;
    }
    
    // Copy-Konstruktor
    public Auto(Auto other) {
        this.farbe = other.farbe;
        this.leistung = other.leistung;
    }
}

Statische vs Instanz-Mitglieder

public class MathUtil {
    // Statische Methode - gehört zur Klasse
    public static int addiere(int a, int b) {
        return a + b;
    }
    
    // Instanzmethode - gehört zum Objekt
    private int wert;
    
    public MathUtil(int startWert) {
        this.wert = startWert;
    }
    
    public int addiereZuWert(int a) {
        this.wert += a;
        return this.wert;
    }
}

// Verwendung
int ergebnis1 = MathUtil.addiere(5, 3);  // Statisch
MathUtil rechner = new MathUtil(10);
int ergebnis2 = rechner.addiereZuWert(5);  // Instanz

Getter und Setter

public class Person {
    private String name;
    private int alter;
    
    // Getter
    public String getName() {
        return name;
    }
    
    // Setter mit Validierung
    public void setAlter(int alter) {
        if (alter >= 0 && alter <= 150) {
            this.alter = alter;
        } else {
            throw new IllegalArgumentException("Ungültiges Alter");
        }
    }
    
    // Getter für berechneten Wert
    public boolean istVolljaehrig() {
        return alter >= 18;
    }
}

Vorteile und Nachteile

Vorteile von OOP

• Wiederverwendbarkeit: Klassen können mehrfach verwendet werden
• Wartbarkeit: Klare Struktur erleichtert Änderungen
• Verständlichkeit: Reale Welt wird nachgebildet
• Kapselung: Daten sind geschützt und kontrolliert zugänglich
• Skalierbarkeit: Große Systeme können strukturiert werden

Nachteile

• Overhead: Mehr Code für einfache Aufgaben
• Lernkurve: Objektorientiertes Denken erfordert Übung
• Performance: Objekterstellung kann teuer sein
• Komplexität: Bei zu vielen Klassen unübersichtlich

Häufige Prüfungsfragen

1. Was ist der Unterschied zwischen Klasse und Objekt? Klasse ist der Bauplan, Objekt ist die konkrete Instanz zur Laufzeit.

2. Erklären Sie die Begriffe Attribut und Methode! Attribute sind Eigenschaften/Daten, Methoden sind Verhalten/Funktionen eines Objekts.

3. Was ist ein Konstruktor? Spezielle Methode zur Initialisierung neuer Objekte, wird bei new aufgerufen.

4. Warum ist Kapselung wichtig? Schützt Daten vor unkontrolliertem Zugriff und ermöglicht Validierung.

Wichtigste Quellen

1. https://de.wikipedia.org/wiki/Objektorientierte_Programmierung
2. https://docs.oracle.com/javase/tutorial/java/concepts/
3. https://docs.python.org/3/tutorial/classes.html