Java - Vererbung
Vererbung kann als der Prozess definiert werden, bei dem eine Klasse die Eigenschaften (Methoden und Felder) einer anderen Klasse erhält. Durch die Verwendung der Vererbung werden die Informationen in einer hierarchischen Reihenfolge verwaltet.
Die Klasse, die die Eigenschaften anderer erbt, wird als Unterklasse (abgeleitete Klasse, untergeordnete Klasse) bezeichnet, und die Klasse, deren Eigenschaften vererbt werden, wird als Oberklasse (Basisklasse, übergeordnete Klasse) bezeichnet.
erweitert Keyword
extendsist das Schlüsselwort, mit dem die Eigenschaften einer Klasse geerbt werden. Es folgt die Syntax des erweiterten Schlüsselworts.
Syntax
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}Beispielcode
Das folgende Beispiel zeigt die Java-Vererbung. In diesem Beispiel können Sie zwei Klassen beobachten, nämlich Berechnung und My_Calculation.
Bei Verwendung des Schlüsselworts extensiv erbt My_Calculation die Methoden Addition () und Subtraction () der Berechnungsklasse.
Kopieren Sie das folgende Programm und fügen Sie es in eine Datei mit dem Namen My_Calculation.java ein
Example
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_CalculationNach dem Ausführen des Programms wird das folgende Ergebnis angezeigt:
Output
The sum of the given numbers:30
The difference between the given numbers:10
The product of the given numbers:200Im gegebenen Programm, wenn ein Objekt zu My_CalculationWenn eine Klasse erstellt wird, wird eine Kopie des Inhalts der Oberklasse darin erstellt. Aus diesem Grund können Sie mit dem Objekt der Unterklasse auf die Mitglieder einer Oberklasse zugreifen.
Die Superclass-Referenzvariable kann das Unterklassenobjekt enthalten. Mit dieser Variablen können Sie jedoch nur auf die Mitglieder der Superklasse zugreifen. Um auf die Mitglieder beider Klassen zuzugreifen, wird empfohlen, immer eine Referenzvariable für die Unterklasse zu erstellen.
Wenn Sie das obige Programm in Betracht ziehen, können Sie die Klasse wie unten angegeben instanziieren. Verwenden Sie jedoch die Referenzvariable der Oberklasse (cal In diesem Fall können Sie die Methode nicht aufrufen multiplication(), die zur Unterklasse My_Calculation gehört.
Calculation demo = new My_Calculation();
demo.addition(a, b);
demo.Subtraction(a, b);Note- Eine Unterklasse erbt alle Mitglieder (Felder, Methoden und verschachtelte Klassen) von ihrer Oberklasse. Konstruktoren sind keine Mitglieder, daher werden sie nicht von Unterklassen geerbt, aber der Konstruktor der Oberklasse kann aus der Unterklasse aufgerufen werden.
Das Super-Schlüsselwort
Das super Schlüsselwort ist ähnlich wie thisStichwort. Es folgen die Szenarien, in denen das Schlüsselwort super verwendet wird.
Es ist daran gewöhnt differentiate the members der Oberklasse von den Mitgliedern der Unterklasse, wenn sie den gleichen Namen haben.
Es ist daran gewöhnt invoke the superclass Konstruktor aus der Unterklasse.
Differenzierung der Mitglieder
Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt. Und wenn die Mitglieder der Oberklasse dieselben Namen wie die Unterklasse haben, verwenden wir zur Unterscheidung dieser Variablen das Schlüsselwort super, wie unten gezeigt.
super.variable
super.method();Beispielcode
In diesem Abschnitt finden Sie ein Programm, das die Verwendung von demonstriert super Stichwort.
In dem angegebenen Programm haben Sie zwei Klassen, nämlich Sub_class und Super_class , beide haben eine Methode namens display () mit unterschiedlichen Implementierungen und eine Variable namens num mit unterschiedlichen Werten. Wir rufen die display () -Methode beider Klassen auf und drucken den Wert der Variablen num beider Klassen. 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 ein.
Example
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 SuperBei Ausführung des Programms erhalten Sie folgendes Ergebnis:
Output
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:20Aufrufen des Superclass-Konstruktors
Wenn eine Klasse die Eigenschaften einer anderen Klasse erbt, erhält 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 wie unten gezeigt verwenden.
super(values);Beispielcode
Das in diesem Abschnitt beschriebene Programm zeigt, wie mit dem Schlüsselwort super der parametrisierte Konstruktor der Oberklasse aufgerufen wird. 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 ein
Example
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 SubclassBei Ausführung des Programms erhalten Sie folgendes Ergebnis:
Output
The value of the variable named age in super class is: 24IS-A-Beziehung
IS-A ist eine Art zu sagen: Dieses Objekt ist ein Typ dieses Objekts. Mal sehen, wie dieextends 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 {
}Basierend auf dem obigen Beispiel ist nun objektorientiert Folgendes wahr:
- Tier ist die Oberklasse der Säugetierklasse.
- Tier ist die Oberklasse der Reptilienklasse.
- Säugetier und Reptil sind Unterklassen der Tierklasse.
- Hund ist die Unterklasse der Säugetier- und Tierklassen.
Wenn wir nun die IS-A-Beziehung betrachten, können wir sagen:
- Säugetier IS-A Tier
- Reptil IS-A Tier
- Hund ist ein Säugetier
- Daher: Hund ist auch ein Tier
Mit dem Schlüsselwort extens können die Unterklassen alle Eigenschaften der Oberklasse mit Ausnahme der privaten Eigenschaften der Oberklasse erben.
Mit dem Instanzoperator können wir sicherstellen, dass Mammal tatsächlich ein Tier ist.
Example
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 führt zu folgendem Ergebnis:
Output
true
true
trueDa haben wir ein gutes Verständnis für die extends Stichwort, lassen Sie uns untersuchen, wie die implements Das Schlüsselwort wird verwendet, um die IS-A-Beziehung abzurufen.
Im Allgemeinen ist die implementsDas Schlüsselwort wird mit Klassen verwendet, um die Eigenschaften einer Schnittstelle zu erben. Schnittstellen können niemals um eine Klasse erweitert werden.
Example
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
}Die Instanz des Schlüsselworts
Verwenden wir die instanceof Bediener zu überprüfen, ob Säugetier tatsächlich ein Tier ist und Hund tatsächlich ein Tier ist.
Example
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 führt zu folgendem Ergebnis:
Output
true
true
trueHAT-A Beziehung
Diese Beziehungen basieren hauptsächlich auf der Verwendung. Dies bestimmt, ob eine bestimmte KlasseHAS-Asichere Sache. Diese Beziehung trägt dazu bei, Doppelarbeit und Fehler zu reduzieren.
Schauen wir uns ein Beispiel an -
Example
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}Dies zeigt, dass Klasse Van HAS-A Speed. Durch eine separate Klasse für Geschwindigkeit müssen wir nicht den gesamten Code, der zur Geschwindigkeit gehört, in die Van-Klasse einfügen, sodass die Geschwindigkeitsklasse in mehreren Anwendungen wiederverwendet werden kann.
In 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. Im Grunde genommen fordern die Benutzer die Van-Klasse auf, eine bestimmte Aktion auszuführen, und die Van-Klasse erledigt die Arbeit entweder selbst oder bittet eine andere Klasse, die Aktion auszuführen.
Arten der Vererbung
Es gibt verschiedene Arten der Vererbung, wie unten gezeigt.
Eine sehr wichtige Tatsache ist, dass Java keine Mehrfachvererbung unterstützt. Dies bedeutet, dass eine Klasse nicht mehr als eine Klasse erweitern kann. Daher ist folgendes illegal -
Example
public class extends Animal, Mammal{}Eine Klasse kann jedoch eine oder mehrere Schnittstellen implementieren, wodurch Java die Unmöglichkeit der Mehrfachvererbung beseitigt hat.