Java Programmieren Lernen

Vererbung und Polymorphismus sind zwei wichtige Konzepte der objektorientierten Programmierung (OOP), die es ermöglichen, Code zu organisieren, zu erweitern und flexibel zu gestalten.

Vererbung

Vererbung ist ein Konzept, bei dem eine Klasse (die sogenannte abgeleitete Klasse oder Subklasse) die Eigenschaften und Methoden einer anderen Klasse (die sogenannte Basisklasse oder Superklasse) erbt. Die abgeleitete Klasse kann dann diese geerbten Eigenschaften und Methoden nutzen und kann zusätzliche Eigenschaften und Methoden hinzufügen oder vorhandene überschreiben.

Beispiel für Vererbung in Java:

// Basisklasse
class Fahrzeug {
    void starten() {
        System.out.println("Das Fahrzeug wird gestartet.");
    }
}

// Abgeleitete Klasse, die von Fahrzeug erbt
class Auto extends Fahrzeug {
    void hupen() {
        System.out.println("Das Auto hupt.");
    }
}

public class Main {
    public static void main(String[] args) {
        Auto auto = new Auto();
        auto.starten(); // Ausgabe: Das Fahrzeug wird gestartet.
        auto.hupen(); // Ausgabe: Das Auto hupt.
    }
}

In diesem Beispiel haben wir eine Basisklasse „Fahrzeug“ definiert, die eine Methode „starten“ hat. Dann haben wir eine abgeleitete Klasse „Auto“ erstellt, die von „Fahrzeug“ erbt und eine zusätzliche Methode „hupen“ hinzufügt. Wenn wir ein Objekt der Klasse „Auto“ erstellen, erben wir automatisch die Methode „starten“ von der Basisklasse „Fahrzeug“ und können zusätzlich die Methode „hupen“ aufrufen.

Polymorphismus

Polymorphismus ist ein weiteres Konzept in der OOP, das es ermöglicht, dass ein Objekt auf unterschiedliche Weisen verwendet werden kann. Es gibt zwei Arten von Polymorphismus in Java: statischer Polymorphismus und dynamischer Polymorphismus.

Statischer Polymorphismus (auch als Überladen bekannt)

Statischer Polymorphismus tritt auf, wenn eine Klasse mehrere Methoden mit demselben Namen hat, aber unterschiedliche Parameter. Der Compiler entscheidet, welche Methode aufgerufen wird, basierend auf den übergebenen Argumenten.

Beispiel für statischen Polymorphismus in Java:

class Berechnungen {

    int addieren(int a, int b) {
        return a + b;
    }

    double addieren(double a, double b) {
        return a + b;
    }
}

public class Main {

    public static void main(String[] args) {
        Berechnungen rechner = new Berechnungen();
        System.out.println(rechner.addieren(2, 3)); // Ausgabe: 5
        System.out.println(rechner.addieren(2.5, 3.5)); // Ausgabe: 6.0
    }
}

In diesem Beispiel haben wir eine Klasse „Berechnungen“ erstellt, die zwei Methoden „addieren“ mit unterschiedlichen Parametertypen hat. Wenn wir die Methode „addieren“ aufrufen, wählt der Compiler die passende Methode basierend auf den übergebenen Argumenten aus.

Dynamischer Polymorphismus (auch als Überschreiben bekannt):

Dynamischer Polymorphismus tritt auf, wenn eine abgeleitete Klasse eine Methode aus der Basisklasse überschreibt, um ihr eigenes Verhalten zu implementieren. Dies geschieht zur Laufzeit und wird auch als „Methodenüberschreibung“ bezeichnet.

Beispiel für dynamischen Polymorphismus in Java:

// Basisklasse
class Tier {

    void lautGeben() {
        System.out.println("Tier macht ein Geräusch.");
    }
}

// Abgeleitete Klasse, die die Methode überschreibt
class Hund extends Tier {

    @Override
    void lautGeben() {
        System.out.println("Der Hund bellt.");
    }
}

public class Main {

    public static void main(String[] args) {
        Tier tier1 = new Tier();
        tier1.lautGeben(); // Ausgabe: Tier macht ein Geräusch.
        Tier tier2 = new Hund();
        tier2.lautGeben(); // Ausgabe: Der Hund bellt.
    }
}

In diesem Beispiel haben wir eine Basisklasse „Tier“ definiert, die eine Methode „lautGeben“ hat. Dann haben wir eine abgeleitete Klasse „Hund“ erstellt, die die Methode „lautGeben“ aus der Basisklasse überschreibt. Wenn wir ein Objekt der Klasse „Hund“ erstellen und die Methode „lautGeben“ aufrufen, wird die überschriebene Methode der abgeleiteten Klasse ausgeführt, nicht die Methode der Basisklasse.

Insgesamt ermöglichen Vererbung und Polymorphismus eine elegante und flexible Strukturierung von Java-Programmen, indem sie die Wiederverwendung von Code fördern und es ermöglichen, dass dieselben Methodennamen auf unterschiedliche Weise verwendet werden können, je nach dem verwendeten Objekttyp.