OOP Grundlagen: Klasse, Objekt, Instanz & Methoden für IHK-Prüfung

Objektorientierte Programmierung (OOP) ist ein fundamentales Paradigma in der modernen Softwareentwicklung. Dieses Lerndokument bereitet dich gezielt auf die IHK-Prüfung vor und erklärt die Kernkonzepte verständlich mit praktischen Beispielen.

Warum OOP? Die Einführung

Stell dir vor, du baust ein Auto. Du würdest nicht jede Schraube, jedes Rad und jedes Teil jedes Mal neu erfinden. Du verwendest vorgefertigte, wiederverwendbare Teile (wie Reifen, Sitze, Motoren), die bestimmte Funktionen haben und untereinander zusammenarbeiten. So funktioniert auch OOP. Es ist ein Programmierparadigma, das Software aus wiederverwendbaren, klar strukturierten “Bausteinen” – den Objekten – zusammensetzt. Dies macht Software besser wartbar, erweiterbar und verständlich.

Der zentrale Unterschied: Klasse vs. Objekt (Instanz)

Das ist das Fundament. Wenn du das verstehst, ergibt alles andere Sinn.

Klasse (Bauplan)

Eine Klasse ist ein abstrakter Bauplan oder eine Schablone. Sie definiert, welche Attribute (Eigenschaften) und Methoden (Fähigkeiten) die daraus erstellten Objekte haben werden.

Beispiel: Die Klasse Auto. Der Bauplan sagt: “Ein Auto hat die Attribute farbe, anzahlTüren und leistungInPS. Es kann die Methoden bremsen() und beschleunigen() ausführen.”

Die Klasse existiert nur einmal im Code.

Objekt / Instanz (konkretes Ding)

Ein Objekt ist eine konkrete Ausprägung (eine “Instanz”) einer Klasse. Es wird zur Laufzeit des Programms aus der Klasse erstellt (new Schlüsselwort in Sprachen wie Java oder C#).

Beispiel: Das Objekt meinGolf ist eine Instanz der Klasse Auto. Es hat die konkreten Attributwerte farbe = "blau", anzahlTüren = 5, leistungInPS = 150. Das Objekt deinA3 ist eine andere Instanz mit den Werten farbe = "schwarz", anzahlTüren = 3, leistungInPS = 120.

Von einer Klasse können beliebig viele Objekte erstellt werden.

Einfache Analogie

Klasse = Der Bauplan für ein Haus (legt fest, es gibt Wände, Türen, Fenster)
Objekt = Das tatsächlich gebaute Haus (konkrete Adresse, Wandfarbe ist weiß, die Tür ist aus Eichenholz)

// Java Beispiel: Klasse vs Objekt
public class Auto {
    // Attribute (Eigenschaften)
    private String farbe;
    private int anzahlTueren;
    private int leistungInPS;
    
    // Konstruktor
    public Auto(String farbe, int anzahlTueren, int leistungInPS) {
        this.farbe = farbe;
        this.anzahlTueren = anzahlTueren;
        this.leistungInPS = leistungInPS;
    }
    
    // Methoden (Fähigkeiten)
    public void beschleunigen() {
        System.out.println("Das " + farbe + "e Auto beschleunigt");
    }
    
    public void bremsen() {
        System.out.println("Das " + farbe + "e Auto bremst");
    }
    
    // Getter und Setter
    public String getFarbe() { return farbe; }
    public void setFarbe(String farbe) { this.farbe = farbe; }
    public int getAnzahlTueren() { return anzahlTueren; }
    public int getLeistungInPS() { return leistungInPS; }
}

// Objekte erstellen (Instanziierung)
public class Main {
    public static void main(String[] args) {
        // Objekt 1
        Auto meinGolf = new Auto("blau", 5, 150);
        meinGolf.beschleunigen();
        
        // Objekt 2
        Auto deinA3 = new Auto("schwarz", 3, 120);
        deinA3.bremsen();
        
        System.out.println("Mein Golf: " + meinGolf.getFarbe() + ", " + 
                          meinGolf.getAnzahlTueren() + " Türen, " + 
                          meinGolf.getLeistungInPS() + " PS");
    }
}

Die vier Prinzipien (Säulen) der OOP

1. Kapselung (Encapsulation)

Was ist das? Das Zusammenfassen von Daten (Attributen) und dem Code, der diese Daten manipuliert (Methoden), zu einer Einheit – der Klasse. Der Zugriff auf die Daten wird kontrolliert, indem sie nach außen hin “versteckt” werden.

Wie funktioniert es? Attribute werden meist als private deklariert. Das bedeutet, von außerhalb der Klasse kann niemand direkt auf meinGolf.leistungInPS zugreifen oder es ändern. Der Zugriff erfolgt ausschließlich über öffentliche Methoden, sogenannte Getter und Setter (auch Zugriffsmethoden genannt).

getLeistungInPS(): Liefert den Wert zurück (Lesen)
setLeistungInPS(int neueLeistung): Ändert den Wert (Schreiben)

Warum ist das so wichtig?

Kontrolle: Die Klasse kann in der set-Methode prüfen, ob der neue Wert sinnvoll ist (z.B. neueLeistung darf nicht negativ sein)
Wartbarkeit: Wenn sich die interne Darstellung ändert (z.B. speicherst du plötzlich die Leistung in kW statt PS), musst du nur die Getter/Setter-Methoden anpassen, nicht aber den gesamten Code, der diese Werte abruft
Datenkonsistenz: Verhindert, dass Objekte in einen ungültigen Zustand gesetzt werden

// Beispiel für Kapselung
public class Bankkonto {
    // Private Attribute - von außen nicht zugreifbar
    private double kontostand;
    private String kontonummer;
    private String inhaber;
    
    public Bankkonto(String kontonummer, String inhaber, double startbetrag) {
        this.kontonummer = kontonummer;
        this.inhaber = inhaber;
        this.kontostand = Math.max(0, startbetrag); // Kontostand darf nicht negativ sein
    }
    
    // Getter - kontrollierter Lesezugriff
    public double getKontostand() {
        return kontostand;
    }
    
    // Setter - kontrollierter Schreibzugriff mit Validierung
    public void setKontostand(double neuerKontostand) {
        if (neuerKontostand >= 0) {
            this.kontostand = neuerKontostand;
        } else {
            System.out.println("Fehler: Kontostand darf nicht negativ sein!");
        }
    }
    
    // Business-Methode mit Kapselung
    public void hebeGeldAb(double betrag) {
        if (betrag > 0 && kontostand >= betrag) {
            kontostand -= betrag;
            System.out.println("Abhebung erfolgreich. Neuer Kontostand: " + kontostand);
        } else {
            System.out.println("Abhebung nicht möglich. Ungültiger Betrag oder unzureichendes Guthaben.");
        }
    }
    
    public void zahleEin(double betrag) {
        if (betrag > 0) {
            kontostand += betrag;
            System.out.println("Einzahlung erfolgreich. Neuer Kontostand: " + kontostand);
        } else {
            System.out.println("Einzahlung nicht möglich. Betrag muss positiv sein.");
        }
    }
}

2. Vererbung (Inheritance)

Was ist das? Eine Möglichkeit, eine neue Klasse (Kindklasse oder Subklasse) auf Basis einer bereits existierenden Klasse (Elternklasse oder Oberklasse) zu definieren. Die Kindklasse erbt alle Attribute und Methoden der Elternklasse.

Warum macht man das? Um Code-Wiederholung zu vermeiden (DRY-Prinzip: Don’t Repeat Yourself) und hierarchische Beziehungen abzubilden.

Beispiel:

Oberklasse: Fahrzeug (mit Attributen geschwindigkeit, hersteller und Methode bewege())
Subklasse: Auto (erbt von Fahrzeug und fügt ein eigenes Attribut anzahlTüren hinzu)
Subklasse: Fahrrad (erbt von Fahrzeug und fügt ein eigenes Attribut anzahlGänge hinzu)

Ein Auto-Objekt hat also automatisch auch geschwindigkeit und kann bewege().

// Beispiel für Vererbung
// Oberklasse (Basisklasse)
public class Fahrzeug {
    protected String hersteller;
    protected int geschwindigkeit;
    protected int baujahr;
    
    public Fahrzeug(String hersteller, int baujahr) {
        this.hersteller = hersteller;
        this.baujahr = baujahr;
        this.geschwindigkeit = 0;
    }
    
    public void beschleunigen(int increment) {
        this.geschwindigkeit += increment;
        System.out.println(hersteller + " beschleunigt auf " + geschwindigkeit + " km/h");
    }
    
    public void bremsen(int decrement) {
        this.geschwindigkeit = Math.max(0, geschwindigkeit - decrement);
        System.out.println(hersteller + " bremst auf " + geschwindigkeit + " km/h");
    }
    
    public void bewege() {
        System.out.println("Das " + hersteller + " Fahrzeug bewegt sich mit " + geschwindigkeit + " km/h");
    }
    
    // Getter
    public String getHersteller() { return hersteller; }
    public int getGeschwindigkeit() { return geschwindigkeit; }
    public int getBaujahr() { return baujahr; }
}

// Subklasse 1
public class Auto extends Fahrzeug {
    private int anzahlTueren;
    private String kraftstoffart;
    
    public Auto(String hersteller, int baujahr, int anzahlTueren, String kraftstoffart) {
        super(hersteller, baujahr); // Aufruf des Konstruktors der Oberklasse
        this.anzahlTueren = anzahlTueren;
        this.kraftstoffart = kraftstoffart;
    }
    
    // Eigene Methode der Subklasse
    public void hupen() {
        System.out.println("Das " + hersteller + " Auto hupt!");
    }
    
    // Methode der Oberklasse überschreiben
    @Override
    public void bewege() {
        System.out.println("Das " + anzahlTueren + "-türige " + hersteller + 
                          " Auto fährt auf der Straße mit " + geschwindigkeit + " km/h");
    }
    
    // Getter
    public int getAnzahlTueren() { return anzahlTueren; }
    public String getKraftstoffart() { return kraftstoffart; }
}

// Subklasse 2
public class Fahrrad extends Fahrzeug {
    private int anzahlGaenge;
    private String fahrzeugtyp = "Fahrrad";
    
    public Fahrrad(String hersteller, int baujahr, int anzahlGaenge) {
        super(hersteller, baujahr);
        this.anzahlGaenge = anzahlGaenge;
    }
    
    // Eigene Methode
    public void schalten(int gang) {
        if (gang >= 1 && gang <= anzahlGaenge) {
            System.out.println("Schalte in Gang " + gang);
        } else {
            System.out.println("Ungültiger Gang!");
        }
    }
    
    // Methode überschreiben
    @Override
    public void bewege() {
        System.out.println("Das " + hersteller + " Fahrrad mit " + anzahlGaenge + 
                          " Gängen bewegt sich mit " + geschwindigkeit + " km/h");
    }
}

3. Polymorphie (Vielgestaltigkeit)

Was ist das? Die Fähigkeit, dass ein Objekt einer Subklasse auch als Objekt seiner Oberklasse behandelt werden kann. Methoden können in Subklassen überschrieben werden, um ein spezifisches Verhalten zu implementieren.

Beispiel: Die Methode bewege() ist in der Oberklasse Fahrzeug definiert. In der Klasse Auto wird sie überschrieben, um “Das Auto fährt auf der Straße” auszugeben. In der Klasse Flugzeug (die auch von Fahrzeug erbt) wird sie überschrieben, um “Das Flugzeug fliegt durch die Luft” auszugeben.

Vorteil: Der Code, der die bewege()-Methode aufruft, muss nicht wissen, um welchen konkreten Typ (Auto oder Flugzeug) es sich handelt. Er ruft einfach bewege() auf dem Objekt vom Typ Fahrzeug auf. Zur Laufzeit wird automatisch die richtige, überschriebene Methode der tatsächlichen Klasse des Objekts ausgeführt. Das macht den Code extrem flexibel.

// Beispiel für Polymorphie
public class PolymorphieDemo {
    public static void main(String[] args) {
        // Verschiedene Fahrzeug-Objekte
        Fahrzeug meinAuto = new Auto("VW", 2020, 4, "Benzin");
        Fahrzeug meinFahrrad = new Fahrrad("Cube", 2021, 21);
        Fahrzeug meinMotorrad = new Motorrad("Yamaha", 2019, 600);
        
        // Polymorphie: Alle werden als Fahrzeug behandelt
        Fahrzeug[] fahrzeuge = {meinAuto, meinFahrrad, meinMotorrad};
        
        // Dynamische Bindung: Zur Laufzeit wird die richtige Methode aufgerufen
        for (Fahrzeug fahrzeug : fahrzeuge) {
            fahrzeug.beschleunigen(50);
            fahrzeug.bewege();  // Ruft die überschriebene Methode der jeweiligen Subklasse auf
            fahrzeug.bremsen(20);
            System.out.println("---");
        }
        
        // Typ-Prüfung und Downcasting
        for (Fahrzeug fahrzeug : fahrzeuge) {
            if (fahrzeug instanceof Auto) {
                Auto auto = (Auto) fahrzeug;  // Downcasting
                auto.hupen();
            } else if (fahrzeug instanceof Fahrrad) {
                Fahrrad fahrrad = (Fahrrad) fahrzeug;
                fahrrad.schalten(5);
            }
        }
    }
}

// Zusätzliche Subklasse für das Beispiel
class Motorrad extends Fahrzeug {
    private int hubraum;
    
    public Motorrad(String hersteller, int baujahr, int hubraum) {
        super(hersteller, baujahr);
        this.hubraum = hubraum;
    }
    
    @Override
    public void bewege() {
        System.out.println("Das " + hersteller + " Motorrad mit " + hubraum + 
                          " ccm fährt mit " + geschwindigkeit + " km/h");
    }
    
    public void wheelie() {
        System.out.println("Das " + hersteller + " Motorrad macht ein Wheelie!");
    }
}

4. Abstraktion (Abstraction)

Was ist das? Das Prinzip, die komplexe Realität auf die für den Kontext wesentlichen Eigenschaften zu reduzieren und unnötige Details zu verbergen.

Beispiel: Wenn du ein Auto als Auto-Objekt modellierst, kümmerst du dich um Attribute wie leistung und Methoden wie bremsen(). Die Details, wie die Bremse genau funktioniert (Hydraulik, Bremsbeläge, etc.), sind für die meisten Programme irrelevant und werden “wegabstrahiert”. Du rufst einfach bremsen() auf.

Abstraktion wird primär durch zwei Dinge erreicht:

Abstrakte Klassen: Klassen, die nicht instanziiert werden können, sondern nur als Vorlage für andere Klassen dienen. Sie können abstrakte Methoden definieren (Methoden ohne Körper, die die Subklasse implementieren muss).
Interfaces (Schnittstellen): Siehe nächster Abschnitt.

// Beispiel für Abstraktion
// Abstrakte Klasse
public abstract class Tier {
    protected String name;
    protected int alter;
    
    public Tier(String name, int alter) {
        this.name = name;
        this.alter = alter;
    }
    
    // Konkrete Methode
    public void schlafen() {
        System.out.println(name + " schläft.");
    }
    
    public void fressen() {
        System.out.println(name + " frisst.");
    }
    
    // Abstrakte Methoden - müssen von Subklassen implementiert werden
    public abstract void machGeraeusch();
    public abstract void bewegeDich();
    
    // Getter
    public String getName() { return name; }
    public int getAlter() { return alter; }
}

// Konkrete Subklassen
public class Hund extends Tier {
    private String rasse;
    
    public Hund(String name, int alter, String rasse) {
        super(name, alter);
        this.rasse = rasse;
    }
    
    @Override
    public void machGeraeusch() {
        System.out.println(name + " bellt: Wuff! Wuff!");
    }
    
    @Override
    public void bewegeDich() {
        System.out.println(name + " läuft auf vier Beinen.");
    }
    
    public void apportieren() {
        System.out.println(name + " apportiert den Ball.");
    }
}

public class Katze extends Tier {
    private String fellfarbe;
    
    public Katze(String name, int alter, String fellfarbe) {
        super(name, alter);
        this.fellfarbe = fellfarbe;
    }
    
    @Override
    public void machGeraeusch() {
        System.out.println(name + " miaut: Miau!");
    }
    
    @Override
    public void bewegeDich() {
        System.out.println(name + " schleicht sich an.");
    }
    
    public void kratzen() {
        System.out.println(name + " kratzt am Kratzbaum.");
    }
}

Wichtige Begriffe der OOP

Attribut (Eigenschaft)

Eine Variable, die einen Zustand oder eine Eigenschaft eines Objekts beschreibt (z.B. farbe, alter, kontostand).

Methode

Eine Funktion oder Prozedur, die in einer Klasse definiert ist und ein Verhalten des Objekts beschreibt (z.B. bezahlen(), druckeDokument()). Ein Methodenaufruf (oder Nachricht) ist die Aufforderung an ein Objekt, eine bestimmte Methode auszuführen (z.B. meinKonto.hebeGeldAb(50)).

Persistenz

Das dauerhafte Speichern des Zustands von Objekten (ihrer Attributwerte), sodass dieser über das Beenden des Programms hinaus erhalten bleibt. Dies geschieht typischerweise in einer Datenbank oder einer Datei. Ein Objekt selbst “lebt” nur im Arbeitsspeicher (RAM) zur Laufzeit des Programms.

// Beispiel für Persistenz
import java.io.*;
import java.util.*;

public class PersistenzBeispiel {
    
    // Objekt speichern
    public static void speichereKonto(Bankkonto konto, String dateiname) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(dateiname))) {
            oos.writeObject(konto);
            System.out.println("Konto wurde gespeichert in " + dateiname);
        } catch (IOException e) {
            System.out.println("Fehler beim Speichern: " + e.getMessage());
        }
    }
    
    // Objekt laden
    public static Bankkonto ladeKonto(String dateiname) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(dateiname))) {
            Bankkonto konto = (Bankkonto) ois.readObject();
            System.out.println("Konto wurde geladen aus " + dateiname);
            return konto;
        } catch (IOException | ClassNotFoundException e) {
            System.out.println("Fehler beim Laden: " + e.getMessage());
            return null;
        }
    }
    
    public static void main(String[] args) {
        Bankkonto meinKonto = new Bankkonto("DE123456789", "Max Mustermann", 1000.0);
        meinKonto.zahleEin(500.0);
        
        // Speichern
        speichereKonto(meinKonto, "konto.ser");
        
        // Laden
        Bankkonto geladenesKonto = ladeKonto("konto.ser");
        if (geladenesKonto != null) {
            System.out.println("Geladenes Konto - Kontostand: " + geladenesKonto.getKontostand());
        }
    }
}

// Serializable Interface für Persistenz
class Bankkonto implements Serializable {
    private static final long serialVersionUID = 1L;
    
    private double kontostand;
    private String kontonummer;
    private String inhaber;
    
    // ... restliche Implementierung wie oben
}

Schnittstelle / API / Interface

(Achtung: Dieser Begriff hat zwei Bedeutungen!)

Im Allgemeinen: Eine Schnittstelle (oder API - Application Programming Interface) definiert eine Vertragsbeschreibung, was etwas tun kann, ohne zu sagen, wie es gemacht wird. Es ist eine Sammlung von Methodensignaturen (Name, Parameter, Rückgabetyp).
Als Sprachkonstrukt (interface): Ein spezielles Sprachkonstrukt in OOP-Sprachen, das genau diese Verträge formal definiert. Eine Klasse, die ein Interface implementiert, muss alle darin definierten Methoden implementieren (mit Code füllen).

Der Unterschied: Klasse vs. Interface

Merkmal	Klasse	Interface
Was ist es?	Ein Bauplan für Objekte	Ein Vertrag oder eine Spezifikation für Fähigkeiten
Enthält…	Implementierung (Code für Methoden), Attribute, Konstruktoren	Nur Methoden-Signaturen (Name, Parameter, Rückgabetyp) ohne Implementierung (keinen Code-Körper)
Schlüsselwörter	`class`, `extends` (Vererbung)	`interface`, `implements` (Implementieren)
Vererbung	Eine Klasse kann von nur einer anderen Klasse erben (einfache Vererbung)	Eine Klasse kann mehrere Interfaces implementieren
Instanziierung	Kann mit `new` instanziiert werden (Objekte erzeugen)	Kann NICHT instanziiert werden
Zweck	Zustand und Verhalten implementieren	Ein Verhalten vorschreiben

Analogie

Klasse = Ein bestimmter Angestellter: “Max Mustermann, Softwareentwickler” kennt die Firma SAP und kann Java-Code schreiben (Implementierung)
Interface = Die Stellenausschreibung: “Wir suchen einen Java-Entwickler mit SAP-Kenntnissen.” Sie listet nur die Anforderungen (Fähigkeiten) auf, die der Bewerber mitbringen muss

// Interface-Beispiel
interface Fliegend {
    void fliegen();
    void landen();
}

interface Schwimmend {
    void schwimmen();
    void tauchen();
}

// Klasse implementiert mehrere Interfaces
public class Ente implements Fliegend, Schwimmend {
    private String name;
    
    public Ente(String name) {
        this.name = name;
    }
    
    // Interface-Methoden implementieren
    @Override
    public void fliegen() {
        System.out.println(name + " fliegt in die Luft");
    }
    
    @Override
    public void landen() {
        System.out.println(name + " landet auf dem Wasser");
    }
    
    @Override
    public void schwimmen() {
        System.out.println(name + " schwimmt elegant");
    }
    
    @Override
    public void tauchen() {
        System.out.println(name + " taucht nach Fischen");
    }
    
    // Eigene Methode
    public void quaken() {
        System.out.println(name + " quakt: Quak! Quak!");
    }
}

// Polymorphie mit Interfaces
public class InterfaceDemo {
    public static void main(String[] args) {
        Ente meineEnte = new Ente("Donald");
        
        // Als Ente behandeln
        meineEnte.quaken();
        
        // Als Fliegend behandeln
        Fliegend fliegendeEnte = meineEnte;
        fliegendeEnte.fliegen();
        fliegendeEnte.landen();
        
        // Als Schwimmend behandeln
        Schwimmend schwimmendeEnte = meineEnte;
        schwimmendeEnte.schwimmen();
        schwimmendeEnte.tauchen();
    }
}

Der Unterschied: Klassenbibliothek vs. Framework

Dies ist ein wichtiger konzeptioneller Unterschied, der oft abgefragt wird.

Klassenbibliothek (Library / SDK)

Du kontrollierst den Ablauf. Eine Bibliothek ist eine Sammlung von vorgefertigten Klassen und Methoden, die du in deinem Code verwenden kannst, wann und wie du es für nötig hältst.
Analogie: Eine Werkzeugkiste. Du baust ein Regal und holst dir aus der Kiste einen Hammer (Hammerklasse.schlagZu()), dann eine Säge (Saegeklasse.saege()). Du bestimmst die Reihenfolge und den Zweck.
Beispiele: Java Standard Library, Apache Commons, jQuery.

Framework

Das Framework kontrolliert den Ablauf. Ein Framework ist ein grundlegendes Skelett oder Gerüst für eine bestimmte Art von Anwendung. Du füllst die vorgegebenen Stellen mit deinem Code. Das Framework ruft deinen Code auf (Prinzip des Hollywood-Prinzips: “Don’t call us, we’ll call you”).
Analogie: Das Framework ist der Bauplan für ein ganzes Haus inklusive vorgefertigter Wände und Leitungen. Du musst nur noch die Steckdosen anbringen und die Tapete auswählen (d.h. deinen Code in die vordefinierten Methoden eintragen). Der Bauplan (das Framework) bestimmt den Ablauf.
Beispiele: Spring (Java), .NET Framework, Angular, React (Web), JUnit (Testing).

Zusammenfassend: Du benutzt eine Bibliothek. Du arbeitest in einem Framework.

// Bibliothek vs. Framework Beispiel

// Bibliothek: Du rufst die Methoden auf
import java.util.ArrayList;
import java.util.Collections;

public class BibliothekBeispiel {
    public static void main(String[] args) {
        // Du bestimmst den Ablauf
        ArrayList<String> namen = new ArrayList<>();
        namen.add("Alice");
        namen.add("Bob");
        namen.add("Charlie");
        
        // Du verwendest Bibliotheksmethoden wann du willst
        Collections.sort(namen);
        System.out.println("Sortierte Namen: " + namen);
    }
}

// Framework: Das Framework ruft deinen Code auf
// Beispiel mit JUnit Testing Framework
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class FrameworkBeispiel {
    
    @Test  // Das Framework ruft diese Methode auf
    public void testAddition() {
        // Du füllst die vordefinierte Methode mit deinem Code
        int result = 2 + 3;
        assertEquals(5, result, "2 + 3 sollte 5 ergeben");
    }
    
    @Test  // Noch eine Methode, die das Framework aufruft
    public void testSubtraction() {
        int result = 10 - 4;
        assertEquals(6, result, "10 - 4 sollte 6 ergeben");
    }
}

Zusammenfassung für die IHK-Prüfung

Klasse vs. Objekt: Bauplan vs. konkretes Ding
Die 4 Prinzipien:
- Kapselung: Verstecke Daten, biete kontrollierten Zugriff
- Vererbung: Erbe Eigenschaften und Methoden, vermeide Redundanz
- Polymorphie: Überschreibe Methoden, um subtypespezifisches Verhalten zu ermöglichen
- Abstraktion: Verberge unnötige Details
Interface vs. Klasse: Interface definiert was, Klasse definiert wie
Bibliothek vs. Framework: Du benutzt die Bibliothek, das Framework benutzt dich

Prüfungsrelevante Konzepte

Wichtige Unterscheidungen

Konzept	Beschreibung	Prüfungsrelevant
Klasse	Bauplan für Objekte	✅
Objekt/Instanz	Konkrete Ausprägung einer Klasse	✅
Attribut	Eigenschaft eines Objekts	✅
Methode	Verhalten eines Objekts	✅
Vererbung	Code-Wiederverwendung durch Hierarchie	✅
Polymorphie	Vielgestaltigkeit durch Überschreiben	✅
Kapselung	Datenverbergung mit Getter/Setter	✅
Abstraktion	Komplexitätsreduktion	✅

Typische Prüfungsaufgaben

Erklären Sie den Unterschied zwischen Klasse und Objekt
Beschreiben Sie die vier OOP-Prinzipien
Implementieren Sie eine einfache Vererbungshierarchie
Erklären Sie Kapselung mit Getter/Setter-Methoden
Unterscheiden Sie Interface von Klasse
Vergleichen Sie Bibliothek und Framework

Diese Grundlagen sind essenziell für das Verständnis moderner Softwareentwicklung und bilden die Basis für fortgeschrittene Konzepte wie Design Patterns, Frameworks und Architekturprinzipien.

OOP Grundlagen: Klasse, Objekt, Instanz & Methoden für IHK-Prüfung

OOP Grundlagen: Klasse, Objekt, Instanz & Methoden für IHK-Prüfung

Warum OOP? Die Einführung

Der zentrale Unterschied: Klasse vs. Objekt (Instanz)

Klasse (Bauplan)

Objekt / Instanz (konkretes Ding)

Einfache Analogie

Die vier Prinzipien (Säulen) der OOP

1. Kapselung (Encapsulation)

2. Vererbung (Inheritance)

3. Polymorphie (Vielgestaltigkeit)

4. Abstraktion (Abstraction)

Wichtige Begriffe der OOP

Attribut (Eigenschaft)

Methode

Persistenz

Schnittstelle / API / Interface

Der Unterschied: Klasse vs. Interface

Analogie

Der Unterschied: Klassenbibliothek vs. Framework

Klassenbibliothek (Library / SDK)

Framework

Zusammenfassung für die IHK-Prüfung

Prüfungsrelevante Konzepte

Wichtige Unterscheidungen

Typische Prüfungsaufgaben

Ähnliche Beiträge

OOP Klassenbeziehungen: Assoziation, Aggregation, Komposition & Vererbung

OOP Vererbung Grundlagen: Inheritance & Polymorphie

UML Polymorphie Grundlagen: Dynamische Bindung & Überschreiben