Java OOP-Tutorial: Vererbung und Polymorphie Lab

Einführung

In diesem Lab werden wir zwei grundlegende Konzepte der objektorientierten Programmierung in Java erkunden: Vererbung (inheritance) und Polymorphismus. Diese leistungsstarken Funktionen ermöglichen es uns, organisierter, effizienter und flexibleren Code zu schreiben. Wir beginnen mit der Vererbung, die es uns ermöglicht, neue Klassen auf der Grundlage bestehender zu erstellen, und gehen dann zum Polymorphismus über, der es uns erlaubt, Objekte unterschiedlicher Klassen einheitlich zu behandeln.

Bis zum Ende dieses Labs können Sie:

Klassenhierarchien mit Vererbung erstellen
Methoden in Unterklassen überschreiben
Polymorphismus verstehen und anwenden
Abstrakte Klassen und Methoden implementieren

Machen Sie sich keine Sorgen, wenn diese Begriffe komplex klingen – wir werden alles in einfache, leicht zu verstehende Schritte zerlegen. Lassen Sie uns unsere spannende Reise beginnen, um Ihre Java-Programmierkenntnisse zu verbessern!

Erstellen einer Basisklasse

Wir beginnen mit der Erstellung einer Basisklasse namens Animal. Diese Klasse wird als Grundlage für unsere anderen Klassen dienen.

Öffnen Sie Ihr Terminal und navigieren Sie in Ihr Projektverzeichnis:
```
cd ~/project
```
Erstellen Sie eine neue Datei namens Animal.java mit dem touch-Befehl:
```
touch Animal.java
```
Öffnen Sie Animal.java in Ihrem Texteditor und fügen Sie folgenden Code hinzu:
```
public class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void sleep() {
        System.out.println(name + " is sleeping.");
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}
```
Lassen Sie uns diesen Code analysieren:
- Wir definieren eine Klasse namens Animal mit zwei Attributen: name (ein String) und age (ein int).
- Das Schlüsselwort private bedeutet, dass diese Attribute nur innerhalb der Klasse zugänglich sind.
- Wir haben einen Konstruktor, der diese Attribute initialisiert, wenn ein Animal-Objekt erstellt wird.
- Wir haben zwei Methoden: eat() und sleep(), die ausgeben, was das Tier gerade tut.
- Wir haben auch "Getter"-Methoden (getName() und getAge()), die es uns ermöglichen, die privaten Attribute von außerhalb der Klasse zuzugreifen.
Speichern Sie die Datei Animal.java.

Speichern der Animal.java-Datei

Jetzt lassen Sie uns unsere Animal-Klasse kompilieren, um sicherzustellen, dass keine Fehler vorliegen. Führen Sie in Ihrem Terminal folgenden Befehl aus:
```
javac Animal.java
```
Wenn keine Fehlermeldungen angezeigt werden, wurde Ihre Klasse erfolgreich kompiliert!

Erstellen einer Unterklasse

Nachdem wir unsere Basisklasse Animal haben, erstellen wir eine Unterklasse namens Dog. Dies demonstriert, wie Vererbung in Java funktioniert.

Erstellen Sie in Ihrem Terminal eine neue Datei namens Dog.java:
```
touch Dog.java
```
Öffnen Sie Dog.java in Ihrem Texteditor und fügen Sie den folgenden Code hinzu:
```
public class Dog extends Animal {
    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);  // Call the superclass constructor
        this.breed = breed;
    }

    public String getBreed() {
        return breed;
    }
}
```
Lassen Sie uns diesen neuen Code aufschlüsseln:
- extends Animal sagt Java, dass Dog eine Unterklasse von Animal ist. Während Dog von Animal erbt, sind die privaten Attribute name und age in Animal in Dog nicht direkt zugänglich. Dog kann jedoch über die geerbten öffentlichen Getter-Methoden getName() und getAge() auf diese Attribute zugreifen.
- Wir haben ein neues Attribut breed hinzugefügt, das spezifisch für Dog ist.
- Der Konstruktor nimmt drei Parameter entgegen. Er verwendet super(name, age), um den Animal-Konstruktor aufzurufen, und setzt dann breed.
- Wir haben eine neue Methode getBreed() hinzugefügt, die spezifisch für Dog ist.
Speichern Sie die Datei Dog.java.
Kompilieren Sie die Dog-Klasse:
```
javac Dog.java
```
Möglicherweise sehen Sie eine Warnung bezüglich Animal.class, aber das ist im Moment in Ordnung.

Veranschaulichung der Vererbung

Jetzt, da wir die Klassen Animal und Dog haben, erstellen wir ein Programm, um zu zeigen, wie Vererbung (inheritance) funktioniert.

Erstellen Sie eine neue Datei namens InheritanceDemo.java:
```
touch InheritanceDemo.java
```

Öffnen Sie InheritanceDemo.java und fügen Sie folgenden Code hinzu:

public class InheritanceDemo {
    public static void main(String[] args) {
        Animal genericAnimal = new Animal("Generic Animal", 5);
        Dog myDog = new Dog("Buddy", 3, "Labrador");

        System.out.println("Demonstrating Animal class:");
        genericAnimal.eat();
        genericAnimal.sleep();

        System.out.println("\nDemonstrating Dog class:");
        myDog.eat();  // Inherited from Animal
        myDog.sleep();  // Inherited from Animal

        System.out.println("\nDog details:");
        System.out.println("Name: " + myDog.getName());  // Inherited method
        System.out.println("Age: " + myDog.getAge());  // Inherited method
        System.out.println("Breed: " + myDog.getBreed());  // Dog-specific method
    }
}

Dieses Programm erstellt Instanzen sowohl der Animal- als auch der Dog-Klasse und zeigt, wie die Dog-Klasse Methoden von der Animal-Klasse erbt.

Speichern Sie die Datei InheritanceDemo.java.

Kompilieren und führen Sie das Programm aus:

javac InheritanceDemo.java
java InheritanceDemo

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Demonstrating Animal class:
Generic Animal is eating.
Generic Animal is sleeping.

Demonstrating Dog class:
Buddy is eating.
Buddy is sleeping.

Dog details:
Name: Buddy
Age: 3
Breed: Labrador

Diese Demonstration zeigt, wie die Dog-Klasse Attribute und Methoden von der Animal-Klasse erbt und gleichzeitig ihr eigenes spezifisches Attribut (breed) und ihre eigene spezifische Methode (getBreed()) hinzufügt.

Methodenüberschreibung

Die Methodenüberschreibung (Method Overriding) ist eine Funktion, die es einer Unterklasse ermöglicht, eine spezifische Implementierung einer Methode bereitzustellen, die bereits in ihrer Oberklasse definiert ist. Schauen wir uns an, wie das funktioniert.

Öffnen Sie Dog.java und fügen Sie die folgende Methode hinzu:
```
@Override
public void eat() {
    System.out.println(getName() + " is eating dog food.");
}
```
Fügen Sie diese Methode innerhalb der Dog-Klasse, aber außerhalb aller anderen Methoden hinzu.

Die @Override-Annotation teilt dem Compiler mit, dass wir beabsichtigen, eine Methode aus der Oberklasse zu überschreiben. Sie ist nicht erforderlich, aber es ist eine gute Praxis, sie zu verwenden.
Speichern Sie die Datei Dog.java.

Jetzt modifizieren wir unsere InheritanceDemo.java, um die Methodenüberschreibung zu demonstrieren. Öffnen Sie InheritanceDemo.java und ersetzen Sie ihren Inhalt durch:

public class InheritanceDemo {
    public static void main(String[] args) {
        Animal genericAnimal = new Animal("Generic Animal", 5);
        Dog myDog = new Dog("Buddy", 3, "Labrador");

        System.out.println("Demonstrating method overriding:");
        genericAnimal.eat();
        myDog.eat();

        System.out.println("\nDemonstrating inherited method:");
        myDog.sleep();  // This method is still inherited from Animal

        System.out.println("\nDog details:");
        System.out.println("Name: " + myDog.getName());
        System.out.println("Age: " + myDog.getAge());
        System.out.println("Breed: " + myDog.getBreed());
    }
}

Speichern Sie die Datei InheritanceDemo.java.

Kompilieren und führen Sie das aktualisierte Programm aus:

javac Animal.java Dog.java InheritanceDemo.java
java InheritanceDemo

Beispiel für die Ausgabe der Methodenüberschreibung

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Demonstrating method overriding:
Generic Animal is eating.
Buddy is eating dog food.

Demonstrating inherited method:
Buddy is sleeping.

Dog details:
Name: Buddy
Age: 3
Breed: Labrador

Dies zeigt, wie die Methodenüberschreibung es der Dog-Klasse ermöglicht, ihre eigene Implementierung der eat()-Methode bereitzustellen, während sie immer noch andere Methoden wie sleep() von der Animal-Klasse erbt.

Einführung in die Polymorphie

Polymorphie ist ein grundlegendes Konzept in der objektorientierten Programmierung, das es uns ermöglicht, eine Referenz auf eine Basisklasse zu verwenden, um auf ein Objekt einer Unterklasse zu verweisen. Dies ermöglicht flexibleren und wiederverwendbaren Code. Schauen wir uns an, wie es funktioniert.

Erstellen Sie eine neue Datei namens Cat.java:
```
touch Cat.java
```

Öffnen Sie Cat.java und fügen Sie folgenden Code hinzu:

public class Cat extends Animal {
    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(getName() + " is eating fish.");
    }

    public void meow() {
        System.out.println(getName() + " says: Meow!");
    }
}

Dies erstellt eine weitere Unterklasse von Animal mit ihrer eigenen eat()-Methode und einer neuen meow()-Methode.

Speichern Sie die Datei Cat.java.

Jetzt aktualisieren wir unsere InheritanceDemo.java, um die Polymorphie zu demonstrieren. Ersetzen Sie ihren Inhalt durch:

public class InheritanceDemo {
    public static void main(String[] args) {
        Animal[] animals = new Animal[3];
        animals[0] = new Animal("Generic Animal", 5);
        animals[1] = new Dog("Buddy", 3, "Labrador");
        animals[2] = new Cat("Whiskers", 2);

        System.out.println("Demonstrating polymorphism:");
        for (Animal animal : animals) {
            animal.eat();  // This will call the appropriate eat() method for each animal
        }

        System.out.println("\nAccessing specific methods:");
        ((Dog) animals[1]).getBreed();  // We need to cast to Dog to call Dog-specific methods
        ((Cat) animals[2]).meow();      // We need to cast to Cat to call Cat-specific methods
    }
}

Dieser Code erstellt ein Array von Animal-Objekten, aber wir speichern tatsächlich eine Mischung aus Animal-, Dog- und Cat-Objekten darin. Wenn wir eat() für jedes Tier aufrufen, ruft Java automatisch die entsprechende Version der Methode basierend auf dem tatsächlichen Typ des Objekts auf.

Speichern Sie die Datei InheritanceDemo.java.

Kompilieren und führen Sie das aktualisierte Programm aus:

javac Animal.java Dog.java Cat.java InheritanceDemo.java
java InheritanceDemo

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Demonstrating polymorphism:
Generic Animal is eating.
Buddy is eating dog food.
Whiskers is eating fish.

Accessing specific methods:
Whiskers says: Meow!

Dies zeigt die Polymorphie in Aktion. Wir können alle Objekte als Animal-Objekte behandeln, aber wenn wir die eat()-Methode aufrufen, verhält sich jedes Objekt gemäß seiner spezifischen Klassenimplementierung.

Zusammenfassung

In diesem Lab haben wir einige Schlüsselkonzepte der objektorientierten Programmierung in Java untersucht:

Vererbung (Inheritance): Wir haben eine Basisklasse Animal erstellt und davon die Klassen Dog und Cat abgeleitet. Dies hat es uns ermöglicht, Code wiederzuverwenden und eine logische Hierarchie von Klassen zu erstellen.
Methodenüberschreibung (Method Overriding): Wir haben gesehen, wie Unterklassen ihre eigenen Implementierungen von Methoden bereitstellen können, die in der Oberklasse definiert sind, was eine spezifischere Verhaltensweise ermöglicht.
Polymorphie: Wir haben gelernt, wie man Objekte verschiedener Klassen einheitlich über ihre gemeinsame Oberklasse behandeln kann, was flexibleren und wiederverwendbaren Code ermöglicht.

Diese Konzepte sind grundlegend für Java und die objektorientierte Programmierung im Allgemeinen. Sie ermöglichen es uns, organisiertere, effizientere und flexiblere Code-Strukturen zu erstellen. Wenn Sie Ihre Java-Reise fortsetzen, werden Sie feststellen, dass diese Konzepte in komplexeren Anwendungen weit verbreitet sind.

Denken Sie daran, dass Übung der Schlüssel zum Beherrschen dieser Konzepte ist.

Java Vererbung und Polymorphie

Einführung

Erstellen einer Basisklasse

Erstellen einer Unterklasse

Veranschaulichung der Vererbung

Methodenüberschreibung

Einführung in die Polymorphie

Zusammenfassung