OOP-Prinzipien Java: Einfache Beispiele

Grundlegende OOP-Prinzipien in Java: Einfache Codebeispiele

Die objektorientierte Programmierung (OOP) ist ein zentrales Konzept in der Softwareentwicklung. In Java spielen die OOP-Prinzipien eine entscheidende Rolle. Hier erfährst du mehr über die vier grundlegenden Prinzipien: Vererbung, Polymorphismus, Abstraktion und Kapselung. Mit einfachen Codebeispielen wird dir der Einstieg erleichtert.

Vererbung in Java

Vererbung ermöglicht es dir, eine neue Klasse auf Basis einer bestehenden Klasse zu erstellen. Dies fördert die Wiederverwendbarkeit von Code. In Java wird die Vererbung mit dem Schlüsselwort extends umgesetzt.

class Tier {
    void essen() {
        System.out.println("Das Tier isst");
    }
}
class Hund extends Tier {
    void bellen() {
        System.out.println("Der Hund bellt");
    }
}
public class TestVererbung {
    public static void main(String[] args) {
        Hund hund = new Hund();
        hund.essen();
        hund.bellen();
    }
}

In diesem Beispiel erbt die Klasse Hund von der Klasse Tier. Somit kann ein Hund sowohl essen als auch bellen.

Polymorphismus in Java

Polymorphismus erlaubt es, dass eine Methode in verschiedenen Kontexten unterschiedlich agiert. In Java wird dies häufig durch Methodenüberladung und -überschreibung erreicht.

class Tier {
    void lautGeben() {
        System.out.println("Das Tier macht ein Geräusch");
    }
}
class Katze extends Tier {
    void lautGeben() {
        System.out.println("Die Katze miaut");
    }
}
public class TestPolymorphismus {
    public static void main(String[] args) {
        Tier meinTier = new Katze();
        meinTier.lautGeben();
    }
}

Hier wird die Methode lautGeben in der Klasse Katze überschrieben. Obwohl das Objekt vom Typ Tier ist, wird die Methode der Katze aufgerufen.

Abstraktion in Java

Abstraktion hilft dabei, komplexe Systeme zu vereinfachen, indem nur die wesentlichen Details dargestellt werden. In Java wird dies durch abstrakte Klassen und Schnittstellen erreicht.

abstract class Fahrzeug {
    abstract void fahren();
}
class Auto extends Fahrzeug {
    void fahren() {
        System.out.println("Das Auto fährt");
    }
}
public class TestAbstraktion {
    public static void main(String[] args) {
        Fahrzeug meinAuto = new Auto();
        meinAuto.fahren();
    }
}

Die Klasse Fahrzeug ist abstrakt und definiert die Methode fahren, die in der Klasse Auto konkretisiert wird.

Kapselung in Java

Kapselung bedeutet, dass die Daten einer Klasse vor unbefugtem Zugriff geschützt werden. Dies wird in Java durch Zugriffsmodifikatoren wie private umgesetzt.

class Konto {
    private double saldo;
    public double getSaldo() {
        return saldo;
    }
    public void setSaldo(double saldo) {
        this.saldo = saldo;
    }
}
public class TestKapselung {
    public static void main(String[] args) {
        Konto meinKonto = new Konto();
        meinKonto.setSaldo(1000.0);
        System.out.println("Kontostand: " + meinKonto.getSaldo());
    }
}

In diesem Beispiel ist das Attribut saldo privat und kann nur über die Methoden getSaldo und setSaldo verändert werden.

Zusammenfassung der OOP-Prinzipien in Java

Die OOP-Prinzipien Java – Vererbung, Polymorphismus, Abstraktion und Kapselung – sind essenziell für eine effektive Programmierung. Sie fördern die Wiederverwendbarkeit, Flexibilität und Wartbarkeit deines Codes. Mit den obigen Beispielen hast du einen ersten Einblick in diese Konzepte erhalten.

Weiterführende Schritte

Um dein Wissen weiter zu vertiefen, empfiehlt es sich, die Beispiele selbst auszuprobieren und zu erweitern. So kannst du ein besseres Verständnis für die OOP-Prinzipien in Java entwickeln und deine Programmierfähigkeiten ausbauen.

Letztes Update vor 27 Tagen