Java - Overerving
Overerving kan worden gedefinieerd als het proces waarbij een klasse de eigenschappen (methoden en velden) van een andere verwerft. Met behulp van overerving wordt de informatie in een hiërarchische volgorde beheersbaar gemaakt.
De klasse die de eigenschappen van andere erft, staat bekend als subklasse (afgeleide klasse, onderliggende klasse) en de klasse waarvan de eigenschappen worden overgeërfd, staat bekend als superklasse (basisklasse, bovenliggende klasse).
verlengt zoekwoord
verlengt is het sleutelwoord dat wordt gebruikt om de eigenschappen van een klasse te erven. Hieronder volgt de syntaxis van het trefwoord extends.
Syntaxis
class Super {
.....
.....
}
class Sub extends Super {
.....
.....
}
Voorbeeldcode
Hieronder volgt een voorbeeld dat Java-overerving laat zien. In dit voorbeeld kun je twee klassen observeren, namelijk Berekening en Mijn_Berekening.
Door het trefwoord extends te gebruiken, erft de My_Calculation de methoden optellen() en Aftrekken() van de klasse Berekening.
Kopieer en plak het volgende programma in een bestand met de naam My_Calculation.java
Voorbeeld
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);
}
}
Compileer en voer de bovenstaande code uit zoals hieronder weergegeven.
javac My_Calculation.java java My_Calculation
Na het uitvoeren van het programma zal het het volgende resultaat opleveren −
Uitvoer
The sum of the given numbers:30 The difference between the given numbers:10 The product of the given numbers:200
In het gegeven programma, wanneer een object voor My_Calculation klasse wordt gemaakt, wordt er een kopie van de inhoud van de superklasse in gemaakt. Daarom kun je met het object van de subklasse toegang krijgen tot de leden van een superklasse.
De referentievariabele Superclass kan het subklasse-object bevatten, maar met die variabele heb je alleen toegang tot de leden van de superklasse, dus om toegang te krijgen tot de leden van beide klassen, wordt aanbevolen om altijd een referentievariabele voor de subklasse te maken.
Als u rekening houdt met het bovenstaande programma, kunt u de klasse instantiëren zoals hieronder aangegeven. Maar met behulp van de superklasse referentievariabele ( cal in dit geval) kunt u de methode multiplication() . niet aanroepen , die behoort tot de subklasse My_Calculation.
Calculation demo = new My_Calculation(); demo.addition(a, b); demo.Subtraction(a, b);
Opmerking − Een subklasse erft alle leden (velden, methoden en geneste klassen) van zijn superklasse. Constructors zijn geen leden, dus ze worden niet geërfd door subklassen, maar de constructor van de superklasse kan worden aangeroepen vanuit de subklasse.
Het superzoekwoord
De super zoekwoord lijkt op dit trefwoord. Hieronder volgen de scenario's waarin het superzoekwoord wordt gebruikt.
-
Het wordt gebruikt om de leden te onderscheiden van superklasse van de leden van de subklasse, als ze dezelfde namen hebben.
-
Het wordt gebruikt om de superklasse aan te roepen constructor uit subklasse.
De leden onderscheiden
Als een klasse de eigenschappen van een andere klasse erft. En als de leden van de superklasse dezelfde namen hebben als de subklasse, gebruiken we om deze variabelen te differentiëren het supersleutelwoord zoals hieronder weergegeven.
super.variable super.method();
Voorbeeldcode
Dit gedeelte biedt u een programma dat het gebruik van de super . demonstreert zoekwoord.
In het gegeven programma heb je twee klassen namelijk Sub_class en Super_class , hebben beide een methode met de naam display() met verschillende implementaties, en een variabele met de naam num met verschillende waarden. We roepen de methode display() van beide klassen op en drukken de waarde van de variabele num van beide klassen af. Hier kunt u zien dat we het super-trefwoord hebben gebruikt om de leden van de superklasse te onderscheiden van de subklasse.
Kopieer en plak het programma in een bestand met de naam Sub_class.java.
Voorbeeld
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();
}
}
Compileer en voer de bovenstaande code uit met behulp van de volgende syntaxis.
javac Super_Demo java Super
Bij het uitvoeren van het programma krijgt u het volgende resultaat −
Uitvoer
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
Superclass Constructor aanroepen
Als een klasse de eigenschappen van een andere klasse erft, krijgt de subklasse automatisch de standaardconstructor van de superklasse. Maar als u een geparametriseerde constructor van de superklasse wilt aanroepen, moet u het super-trefwoord gebruiken zoals hieronder weergegeven.
super(values);
Voorbeeldcode
Het programma in deze sectie laat zien hoe het sleutelwoord super gebruikt kan worden om de geparametriseerde constructor van de superklasse aan te roepen. Dit programma bevat een superklasse en een subklasse, waarbij de superklasse een geparametriseerde constructor bevat die een geheel getal accepteert, en we hebben het sleutelwoord super gebruikt om de geparametriseerde constructor van de superklasse aan te roepen.
Kopieer en plak het volgende programma in een bestand met de naam Subclass.java
Voorbeeld
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();
}
}
Compileer en voer de bovenstaande code uit met behulp van de volgende syntaxis.
javac Subclass java Subclass
Bij het uitvoeren van het programma krijgt u het volgende resultaat −
Uitvoer
The value of the variable named age in super class is: 24
IS-A-relatie
IS-A is een manier om te zeggen:Dit object is een type van dat object. Laten we eens kijken hoe de uitbreidt zoekwoord wordt gebruikt om overerving te bereiken.
public class Animal {
}
public class Mammal extends Animal {
}
public class Reptile extends Animal {
}
public class Dog extends Mammal {
}
Nu, op basis van het bovenstaande voorbeeld, in objectgeoriënteerde termen, is het volgende waar −
- Dier is de superklasse van de zoogdierklasse.
- Dier is de superklasse van de Reptielenklasse.
- Zoogdier en Reptielen zijn subklassen van de klasse Dieren.
- Hond is de subklasse van zowel zoogdier- als dierklassen.
Als we nu kijken naar de IS-A-relatie, kunnen we zeggen:
- Zoogdier IS-een dier
- Reptiel IS-een dier
- Hond IS-A Zoogdier
- Vandaar:hond IS ook een dier
Met het gebruik van het sleutelwoord extends kunnen de subklassen alle eigenschappen van de superklasse erven, behalve de privé-eigenschappen van de superklasse.
We kunnen er zeker van zijn dat Zoogdier eigenlijk een Dier is met behulp van de instantie-operator.
Voorbeeld
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);
}
}
Dit levert het volgende resultaat op −
Uitvoer
true true true
Omdat we een goed begrip hebben van de verlengt zoekwoord, laten we eens kijken hoe de implementeert zoekwoord wordt gebruikt om de IS-A-relatie te krijgen.
Over het algemeen zijn de implementaties trefwoord wordt gebruikt met klassen om de eigenschappen van een interface te erven. Interfaces kunnen nooit met een klasse worden uitgebreid.
Voorbeeld
public interface Animal {
}
public class Mammal implements Animal {
}
public class Dog extends Mammal {
}
De instantie van Trefwoord
Laten we de instanceof . gebruiken operator om te controleren of een zoogdier een dier is en een hond een dier.
Voorbeeld
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);
}
}
Dit levert het volgende resultaat op −
Uitvoer
true true true
HAS-A-relatie
Deze relaties zijn voornamelijk gebaseerd op het gebruik. Dit bepaalt of een bepaalde klasse HAS-A bepaald ding. Deze relatie helpt om duplicatie van code en bugs te verminderen.
Laten we een voorbeeld bekijken −
Voorbeeld
public class Vehicle{}
public class Speed{}
public class Van extends Vehicle {
private Speed sp;
}
Hieruit blijkt dat klasse Van HAS-A Speed. Door een aparte klasse voor Speed te hebben, hoeven we niet de hele code die bij snelheid hoort in de Van-klasse te plaatsen, waardoor het mogelijk is om de Speed-klasse in meerdere toepassingen te hergebruiken.
In de objectgeoriënteerde functie hoeven de gebruikers zich geen zorgen te maken over welk object het echte werk doet. Om dit te bereiken verbergt de klasse Van de implementatiedetails voor de gebruikers van de klasse Van. Dus wat er in feite gebeurt, is dat de gebruikers de Van-klasse vragen om een bepaalde actie uit te voeren en de Van-klasse zal het werk zelf doen of een andere klasse vragen om de actie uit te voeren.
Soorten overerving
Er zijn verschillende soorten overerving, zoals hieronder wordt aangetoond.
Een heel belangrijk feit om te onthouden is dat Java geen ondersteuning biedt voor meervoudige overerving. Dit betekent dat een klas niet meer dan één klas kan verlengen. Daarom is volgen illegaal −
Voorbeeld
public class extends Animal, Mammal{}
Een klasse kan echter een of meer interfaces implementeren, wat Java heeft geholpen om de onmogelijkheid van meervoudige overerving te elimineren.
Java