Vererbung in Java-Beispiel

Vererbung in Java ist eines der Kernkonzepte der objektorientierten Programmierung. Java-Vererbung wird verwendet, wenn zwischen Objekten eine „ist-ein“ Beziehung besteht. Vererbung in Java wird mit dem Schlüsselwort extends implementiert.

Vererbung in Java

Vererbung in Java ist die Methode, um eine Hierarchie zwischen Klassen zu erstellen, indem von anderen Klassen geerbt wird.

Java-Vererbung ist transitiv – wenn also Sedan Car erweitert und Car Vehicle erweitert, dann wird Sedan auch von der Vehicle-Klasse geerbt. Das Fahrzeug wird die Superklasse von sowohl Auto als auch Sedan.

Vererbung wird in Java-Anwendungen weit verbreitet eingesetzt, zum Beispiel durch Erweiterung der Exception-Klasse, um eine anwendungsspezifische Exception-Klasse zu erstellen, die weitere Informationen wie Fehlercodes enthält. Zum Beispiel NullPointerException.

Java-Vererbungsbeispiel

Jede Klasse in Java erweitert implizit die Klasse java.lang.Object. Daher befindet sich die Object-Klasse auf der obersten Ebene der Vererbungshierarchie in Java.

Sehen wir uns an, wie Vererbung in Java anhand eines einfachen Beispiels implementiert wird.

Superklasse: Tier

package com.journaldev.inheritance;

public class Animal {

	private boolean vegetarian;

	private String eats;

	private int noOfLegs;

	public Animal(){}

	public Animal(boolean veg, String food, int legs){
		this.vegetarian = veg;
		this.eats = food;
		this.noOfLegs = legs;
	}

	public boolean isVegetarian() {
		return vegetarian;
	}

	public void setVegetarian(boolean vegetarian) {
		this.vegetarian = vegetarian;
	}

	public String getEats() {
		return eats;
	}

	public void setEats(String eats) {
		this.eats = eats;
	}

	public int getNoOfLegs() {
		return noOfLegs;
	}

	public void setNoOfLegs(int noOfLegs) {
		this.noOfLegs = noOfLegs;
	}

}

Die Tierklasse ist hier die Basisklasse. Lassen Sie uns eine Katzenklasse erstellen, die von der Tierklasse erbt.

Unterklasse: Katze

package com.journaldev.inheritance;

public class Cat extends Animal{

	private String color;

	public Cat(boolean veg, String food, int legs) {
		super(veg, food, legs);
		this.color="White";
	}

	public Cat(boolean veg, String food, int legs, String color){
		super(veg, food, legs);
		this.color=color;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

}

Beachten Sie, dass wir das Schlüsselwort extends verwenden, um die Vererbung in Java zu implementieren.

Java-Vererbungstestprogramm

Lassen Sie uns eine einfache Testklasse schreiben, um ein Katzenobjekt zu erstellen und einige seiner Methoden zu verwenden.

package com.journaldev.inheritance;

public class AnimalInheritanceTest {

	public static void main(String[] args) {
		Cat cat = new Cat(false, "milk", 4, "black");

		System.out.println("Cat is Vegetarian?" + cat.isVegetarian());
		System.out.println("Cat eats " + cat.getEats());
		System.out.println("Cat has " + cat.getNoOfLegs() + " legs.");
		System.out.println("Cat color is " + cat.getColor());
	}

}

Ausgabe:

Die Katzenklasse hat keine Methode getEats(), aber dennoch funktioniert das Programm, da sie von der Tierklasse geerbt wird.

Wichtige Punkte

1. Code-Wiederverwendung ist der wichtigste Vorteil der Vererbung, da Unterklassen die Variablen und Methoden der Superklasse erben.

2. Private Elemente der Superklasse sind für die Unterklasse nicht direkt zugänglich. Wie in diesem Beispiel ist die Tiervariable noOfLegs für die Katzenklasse nicht zugänglich, kann aber indirekt über Getter- und Setter-Methoden zugänglich gemacht werden.

3. Elemente der Superklasse mit Standardzugriff sind nur für die Unterklasse zugänglich, wenn sie sich im selben Paket befinden.

4. Konstruktoren der Superklasse werden von der Unterklasse nicht vererbt.

5. Wenn die Superklasse keinen Standardkonstruktor hat, muss die Unterklasse auch einen expliziten Konstruktor haben. Andernfalls wird eine Kompilierzeit-Ausnahme ausgelöst. Im Konstruktor der Unterklasse ist in diesem Fall der Aufruf des Superklassenkonstruktors obligatorisch und er sollte die erste Anweisung im Konstruktor der Unterklasse sein.

6. Java unterstützt keine Mehrfachvererbung, eine Unterklasse kann nur eine Klasse erweitern. Die Klasse Animal erweitert implizit die Klasse Object und die Klasse Cat erweitert die Klasse Animal, aber aufgrund der transitiven Vererbung in Java erweitert die Klasse Cat auch die Klasse Object.

7. Wir können eine Instanz der Unterklasse erstellen und sie dann einer Variablen der Oberklasse zuweisen. Dies wird als Upcasting bezeichnet. Hier ist ein einfaches Beispiel für Upcasting:

   Cat c = new Cat(); // Instanz der Unterklasse
   Animal a = c; // Upcasting, es ist in Ordnung, da Cat auch ein Animal ist
   

8. Wenn einer Instanz der Oberklasse eine Variable der Unterklasse zugewiesen wird, wird dies als Downcasting bezeichnet. Wir müssen dies explizit in die Unterklasse umwandeln. Zum Beispiel;

   Cat c = new Cat();
   Animal a = c;
   Cat c1 = (Cat) a; // explizites Casting, funktioniert gut, weil "c" tatsächlich vom Typ Cat ist
   

   Beachten Sie, dass der Compiler sich nicht beschwert, selbst wenn wir es falsch machen, aufgrund des expliziten Castings. Hier sind einige Fälle, in denen es zur Laufzeit eine ClassCastException auslösen wird.

   Dog d = new Dog();
   Animal a = d;
   Cat c1 = (Cat) a; // ClassCastException zur Laufzeit
   
   Animal a1 = new Animal();
   Cat c2 = (Cat) a1; // ClassCastException, weil a1 zur Laufzeit tatsächlich vom Typ Animal ist
   

9. Wir können die Methode der Oberklasse in der Unterklasse überschreiben. Allerdings sollten wir die überschriebene Methode immer mit @Override Annotation kennzeichnen. Der Compiler wird wissen, dass wir eine Methode überschreiben, und wenn sich etwas in der Methode der Oberklasse ändert, erhalten wir einen Kompilierungsfehler anstelle von unerwünschten Ergebnissen zur Laufzeit.

10. Wir können die Methoden der Superklasse aufrufen und auf Superklassenvariablen zugreifen, indem wir das Schlüsselwort super verwenden. Dies ist nützlich, wenn wir in der Unterklasse eine Variable/Methode mit demselben Namen haben, aber auf die Superklassenvariable/-methode zugreifen möchten. Das wird auch verwendet, wenn Konstruktoren in der Superklasse und Unterklasse definiert sind und wir den Konstruktor der Superklasse explizit aufrufen müssen.

11. Wir können die Anweisung instanceof verwenden, um die Vererbung zwischen Objekten zu überprüfen. Sehen wir uns dies anhand des folgenden Beispiels an.

```
Cat c = new Cat();
Dog d = new Dog();
Animal an = c;

boolean flag = c instanceof Cat; //normal case, returns true

flag = c instanceof Animal; // returns true since c is-an Animal too

flag = an instanceof Cat; //returns true because a is of type Cat at runtime

flag = an instanceof Dog; //returns false for obvious reasons.
```

12. Wir können keine finalen Klassen in Java erweitern.
13. Wenn Sie in Ihrem Code nicht Superklasse verwenden, d. h. Ihre Superklasse nur eine Basis ist, um wiederverwendbaren Code zu halten, können Sie sie als Abstrakte Klasse behalten, um unnötige Instanziierung durch Clientklassen zu vermeiden. Dies wird auch die Instanzerstellung der Basisklasse einschränken.

Java-Vererbungsvideotutorial

I have recently published two videos on YouTube explaining Inheritance in detail with sample programs, you should watch them below.

Sie können weitere Vererbungsbeispiele aus unserem GitHub-Repository überprüfen.

Referenz: Oracle-Dokumentation