Java - Vererbung
Vererbung kann als Prozess definiert werden, bei dem eine Klasse die Eigenschaften (Methoden und Felder) einer anderen erwirbt. Mit der Verwendung von Vererbung werden die Informationen in einer hierarchischen Reihenfolge überschaubar gemacht.
Die Klasse, die die Eigenschaften anderer erbt, wird als Unterklasse (abgeleitete Klasse, Kindklasse) bezeichnet, und die Klasse, deren Eigenschaften geerbt werden, wird als Oberklasse (Basisklasse, Elternklasse) bezeichnet.
erweitert Schlüsselwort
erweitert ist das Schlüsselwort, das verwendet wird, um die Eigenschaften einer Klasse zu erben. Es folgt die Syntax des Schlüsselworts extend.
Syntax
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}
Beispielcode
Im Folgenden finden Sie ein Beispiel, das die Java-Vererbung demonstriert. In diesem Beispiel können Sie zwei Klassen beobachten, nämlich Calculation und My_Calculation.
Unter Verwendung des Schlüsselworts extend erbt My_Calculation die Methoden addition() und Subtraction() der Calculation-Klasse.
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen My_Calculation.java
einBeispiel
Live-Demo
class Calculation {
int z;
public void addition(int x, int y) {
z = x + y;
System.out.println("The sum of the given numbers:"+z);
}
public void Subtraction(int x, int y) {
z = x - y;
System.out.println("The difference between the given numbers:"+z);
}
}
public class My_Calculation extends Calculation {
public void multiplication(int x, int y) {
z = x * y;
System.out.println("The product of the given numbers:"+z);
}
public static void main(String args[]) {
int a = 20, b = 10;
My_Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);
demo.multiplication(a, b);
}
}
Kompilieren Sie den obigen Code und führen Sie ihn wie unten gezeigt aus.
javac My_Calculation.java java My_Calculation
Nach der Ausführung des Programms wird das folgende Ergebnis erzeugt −
Ausgabe
The sum of the given numbers:30 The difference between the given numbers:10 The product of the given numbers:200
Im gegebenen Programm, wenn ein Objekt zu My_Calculation Klasse erstellt wird, wird eine Kopie des Inhalts der Oberklasse innerhalb dieser erstellt. Deshalb können Sie über das Objekt der Unterklasse auf die Mitglieder einer Oberklasse zugreifen.
Die Referenzvariable der Oberklasse kann das Objekt der Unterklasse enthalten, aber mit dieser Variablen können Sie nur auf die Mitglieder der Oberklasse zugreifen. Um auf die Mitglieder beider Klassen zuzugreifen, wird daher empfohlen, immer eine Referenzvariable für die Unterklasse zu erstellen.
Wenn Sie das obige Programm betrachten, können Sie die Klasse wie unten angegeben instanziieren. Aber mit der Oberklassen-Referenzvariable ( cal in diesem Fall) können Sie die Methode multiplication() nicht aufrufen , die zur Unterklasse My_Calculation gehört.
Calculation demo = new My_Calculation(); demo.addition(a, b); demo.Subtraction(a, b);
Hinweis − Eine Unterklasse erbt alle Mitglieder (Felder, Methoden und verschachtelte Klassen) von ihrer Oberklasse. Konstruktoren sind keine Mitglieder, also werden sie nicht von Unterklassen geerbt, aber der Konstruktor der Oberklasse kann von der Unterklasse aufgerufen werden.
Das Super-Keyword
Der super Schlüsselwort ähnelt diesem Stichwort. Im Folgenden sind die Szenarien aufgeführt, in denen das Schlüsselwort super verwendet wird.
-
Es dient zur Unterscheidung der Mitglieder der Oberklasse von den Mitgliedern der Unterklasse, wenn sie denselben Namen haben.
-
Es wird zum Aufrufen der Oberklasse verwendet Konstruktor aus der Unterklasse.
Unterscheidung der Mitglieder
Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt. Und wenn die Mitglieder der Oberklasse die gleichen Namen haben wie die Unterklasse, verwenden wir zur Unterscheidung dieser Variablen das Schlüsselwort super, wie unten gezeigt.
super.variable super.method();
Beispielcode
Dieser Abschnitt stellt Ihnen ein Programm zur Verfügung, das die Verwendung von super demonstriert Schlüsselwort.
In dem angegebenen Programm haben Sie zwei Klassen, nämlich Sub_class und Superklasse , haben beide eine Methode namens display() mit unterschiedlichen Implementierungen und eine Variable namens num mit unterschiedlichen Werten. Wir rufen die Methode display() beider Klassen auf und geben den Wert der Variablen num beider Klassen aus. Hier können Sie beobachten, dass wir das Schlüsselwort super verwendet haben, um die Mitglieder der Oberklasse von der Unterklasse zu unterscheiden.
Kopieren Sie das Programm und fügen Sie es in eine Datei mit dem Namen Sub_class.java.
einBeispiel
Live-Demo
class Super_class {
int num = 20;
// display method of superclass
public void display() {
System.out.println("This is the display method of superclass");
}
}
public class Sub_class extends Super_class {
int num = 10;
// display method of sub class
public void display() {
System.out.println("This is the display method of subclass");
}
public void my_method() {
// Instantiating subclass
Sub_class sub = new Sub_class();
// Invoking the display() method of sub class
sub.display();
// Invoking the display() method of superclass
super.display();
// printing the value of variable num of subclass
System.out.println("value of the variable named num in sub class:"+ sub.num);
// printing the value of variable num of superclass
System.out.println("value of the variable named num in super class:"+ super.num);
}
public static void main(String args[]) {
Sub_class obj = new Sub_class();
obj.my_method();
}
}
Kompilieren Sie den obigen Code und führen Sie ihn mit der folgenden Syntax aus.
javac Super_Demo java Super
Beim Ausführen des Programms erhalten Sie das folgende Ergebnis −
Ausgabe
This is the display method of subclass This is the display method of superclass value of the variable named num in sub class:10 value of the variable named num in super class:20
Aufruf des Oberklassenkonstruktors
Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt, übernimmt die Unterklasse automatisch den Standardkonstruktor der Oberklasse. Wenn Sie jedoch einen parametrisierten Konstruktor der Oberklasse aufrufen möchten, müssen Sie das Schlüsselwort super verwenden, wie unten gezeigt.
super(values);
Beispielcode
Das in diesem Abschnitt angegebene Programm demonstriert, wie das Schlüsselwort super verwendet wird, um den parametrisierten Konstruktor der Oberklasse aufzurufen. Dieses Programm enthält eine Oberklasse und eine Unterklasse, wobei die Oberklasse einen parametrisierten Konstruktor enthält, der einen ganzzahligen Wert akzeptiert, und wir haben das Schlüsselwort super verwendet, um den parametrisierten Konstruktor der Oberklasse aufzurufen.
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen Subclass.java
einBeispiel
Live-Demo
class Superclass {
int age;
Superclass(int age) {
this.age = age;
}
public void getAge() {
System.out.println("The value of the variable named age in super class is: " +age);
}
}
public class Subclass extends Superclass {
Subclass(int age) {
super(age);
}
public static void main(String args[]) {
Subclass s = new Subclass(24);
s.getAge();
}
}
Kompilieren Sie den obigen Code und führen Sie ihn mit der folgenden Syntax aus.
javac Subclass java Subclass
Beim Ausführen des Programms erhalten Sie das folgende Ergebnis −
Ausgabe
The value of the variable named age in super class is: 24
IS-A-Beziehung
IS-A ist eine Art zu sagen:Dieses Objekt ist eine Art dieses Objekts. Lassen Sie uns sehen, wie sich die ausdehnt Schlüsselwort wird verwendet, um Vererbung zu erreichen.
public class Animal {
}
public class Mammal extends Animal {
}
public class Reptile extends Animal {
}
public class Dog extends Mammal {
}
Nun, basierend auf dem obigen Beispiel, ist in objektorientierten Begriffen Folgendes wahr:−
- Tier ist die Oberklasse der Säugetierklasse.
- Animal ist die Oberklasse der Reptile-Klasse.
- Säugetier und Reptil sind Unterklassen der Tierklasse.
- Hund ist die Unterklasse sowohl der Säugetier- als auch der Tierklasse.
Wenn wir nun die IS-A-Beziehung betrachten, können wir sagen −
- Säugetier IST EIN Tier
- Reptil IST EIN Tier
- Hund IST EIN Säugetier
- Daher:Hund IST auch ein Tier
Durch die Verwendung des Schlüsselworts extended können die Unterklassen alle Eigenschaften der Oberklasse erben, mit Ausnahme der privaten Eigenschaften der Oberklasse.
Wir können sicherstellen, dass Säugetier tatsächlich ein Tier ist, indem wir den Instanzoperator verwenden.
Beispiel
Live-Demo
class Animal {
}
class Mammal extends Animal {
}
class Reptile extends Animal {
}
public class Dog extends Mammal {
public static void main(String args[]) {
Animal a = new Animal();
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
Dies wird das folgende Ergebnis erzeugen −
Ausgabe
true true true
Da wir ein gutes Verständnis der Ausdehnungen haben Stichwort, lassen Sie uns untersuchen, wie die implementiert Schlüsselwort wird verwendet, um die IS-A-Beziehung zu erhalten.
Im Allgemeinen die Implementierungen Das Schlüsselwort wird mit Klassen verwendet, um die Eigenschaften einer Schnittstelle zu erben. Schnittstellen können niemals um eine Klasse erweitert werden.
Beispiel
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
}
Die Instanz des Schlüsselworts
Lassen Sie uns die instanceof verwenden Operator, um festzustellen, ob ein Säugetier tatsächlich ein Tier und ein Hund tatsächlich ein Tier ist.
Beispiel
Live-Demo
interface Animal{}
class Mammal implements Animal{}
public class Dog extends Mammal {
public static void main(String args[]) {
Mammal m = new Mammal();
Dog d = new Dog();
System.out.println(m instanceof Animal);
System.out.println(d instanceof Mammal);
System.out.println(d instanceof Animal);
}
}
Dies wird das folgende Ergebnis erzeugen −
Ausgabe
true true true
HAT-A-Beziehung
Diese Beziehungen basieren hauptsächlich auf der Verwendung. Dies bestimmt, ob eine bestimmte Klasse HAS-A hat sichere Sache. Diese Beziehung trägt dazu bei, die Duplizierung von Code sowie Fehler zu reduzieren.
Schauen wir uns ein Beispiel an −
Beispiel
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}
Dies zeigt, dass der Van HAS-A Speed ist. Indem wir eine separate Klasse für Geschwindigkeit haben, müssen wir nicht den gesamten Code, der zur Geschwindigkeit gehört, in die Van-Klasse einfügen, wodurch es möglich wird, die Geschwindigkeitsklasse in mehreren Anwendungen wiederzuverwenden.
Bei der objektorientierten Funktion müssen sich die Benutzer nicht darum kümmern, welches Objekt die eigentliche Arbeit erledigt. Um dies zu erreichen, verbirgt die Van-Klasse die Implementierungsdetails vor den Benutzern der Van-Klasse. Was also im Grunde passiert, ist, dass die Benutzer die Van-Klasse auffordern, eine bestimmte Aktion auszuführen, und die Van-Klasse wird entweder die Arbeit selbst erledigen oder eine andere Klasse bitten, die Aktion auszuführen.
Arten der Vererbung
Wie unten gezeigt, gibt es verschiedene Arten der Vererbung.
Eine sehr wichtige Tatsache, die Sie sich merken sollten, ist, dass Java keine Mehrfachvererbung unterstützt. Dies bedeutet, dass eine Klasse nicht mehr als eine Klasse erweitern kann. Daher ist folgendes nicht erlaubt −
Beispiel
public class extends Animal, Mammal{}
Eine Klasse kann jedoch eine oder mehrere Schnittstellen implementieren, was Java geholfen hat, die Unmöglichkeit der Mehrfachvererbung zu beseitigen.
Java