Java, Inheritance is een belangrijke pijler van OOP (Object-Oriented Programming). Het is het mechanisme in Java waarmee een klasse de kenmerken (velden en methoden) van een andere klasse mag erven. In Java betekent overerving het creëren van nieuwe klassen op basis van bestaande klassen. Een klasse die overerft van een andere klasse kan de methoden en velden van die klasse hergebruiken. Bovendien kunt u ook nieuwe velden en methoden aan uw huidige klasse toevoegen.

Waarom hebben we Java-overerving nodig?

• Herbruikbaarheid van code: De code die in de superklasse is geschreven, is gemeenschappelijk voor alle subklassen. Onderliggende klassen kunnen rechtstreeks de code van de bovenliggende klasse gebruiken.
• Methode overschrijven: Methode overschrijven kan alleen worden bereikt via erfenis. Het is een van de manieren waarop Java Run Time Polymorphism bereikt.
• Abstractie: Het concept van abstractie, waarbij we niet alle details hoeven te verstrekken, wordt bereikt door overerving. Abstractie toont alleen de functionaliteit aan de gebruiker.

Belangrijke terminologieën die worden gebruikt bij Java-overerving

• Klas: Klasse is een verzameling objecten die gemeenschappelijke kenmerken/gedrag en gemeenschappelijke eigenschappen/attributen delen. Klasse is geen echte entiteit. Het is slechts een sjabloon, blauwdruk of prototype waaruit objecten worden gemaakt.
• Superklasse/Ouderklasse: De klasse waarvan de kenmerken worden geërfd, staat bekend als een superklasse (of een basisklasse of een bovenliggende klasse).
• Subklasse/kinderklasse: De klasse die de andere klasse erft, staat bekend als een subklasse (of een afgeleide klasse, uitgebreide klasse of onderliggende klasse). De subklasse kan naast de velden en methoden van de superklasse zijn eigen velden en methoden toevoegen.
• Herbruikbaarheid: Overerving ondersteunt het concept van herbruikbaarheid, dat wil zeggen dat wanneer we een nieuwe klasse willen maken en er al een klasse is die een deel van de code bevat die we willen, we onze nieuwe klasse kunnen afleiden uit de bestaande klasse. Door dit te doen, hergebruiken we de velden en methoden van de bestaande klasse.

Hoe overerving in Java te gebruiken?

De breidt trefwoord uit wordt gebruikt voor overerving op Java. Als u het trefwoord extends gebruikt, geeft u aan dat u bent afgeleid van een bestaande klasse. Met andere woorden, extends verwijst naar verhoogde functionaliteit.

afdrukarray in Java

Syntaxis:

class DerivedClass extends BaseClass  {   //methods and fields  }>

Overerving in Java-voorbeeld

Voorbeeld: In het onderstaande voorbeeld van overerving is klasse Bicycle een basisklasse, is klasse MountainBike een afgeleide klasse die de klasse Bicycle uitbreidt en is klasse Test een bestuurdersklasse om het programma uit te voeren.

// Java program to illustrate the // concept of inheritance // base class class Bicycle {  // the Bicycle class has two fields  public int gear;  public int speed;  // the Bicycle class has one constructor  public Bicycle(int gear, int speed)  {  this.gear = gear;  this.speed = speed;  }  // the Bicycle class has three methods  public void applyBrake(int decrement)  {  speed -= decrement;  }  public void speedUp(int increment)  {  speed += increment;  }  // toString() method to print info of Bicycle  public String toString()  {  return ('No of gears are ' + gear + '
'  + 'speed of bicycle is ' + speed);  } } // derived class class MountainBike extends Bicycle {  // the MountainBike subclass adds one more field  public int seatHeight;  // the MountainBike subclass has one constructor  public MountainBike(int gear, int speed,  int startHeight)  {  // invoking base-class(Bicycle) constructor  super(gear, speed);  seatHeight = startHeight;  }  // the MountainBike subclass adds one more method  public void setHeight(int newValue)  {  seatHeight = newValue;  }  // overriding toString() method  // of Bicycle to print more info  @Override public String toString()  {  return (super.toString() + '
seat height is '  + seatHeight);  } } // driver class public class Test {  public static void main(String args[])  {  MountainBike mb = new MountainBike(3, 100, 25);  System.out.println(mb.toString());  } }>

No of gears are 3 speed of bicycle is 100 seat height is 25>

Wanneer in het bovenstaande programma een object van de MountainBike-klasse wordt gemaakt, verkrijgt een kopie van alle methoden en velden van de superklasse geheugen in dit object. Daarom hebben we door het object van de subklasse te gebruiken ook toegang tot de leden van een superklasse.

Houd er rekening mee dat tijdens de overerving alleen het object van de subklasse wordt gemaakt, en niet de superklasse. Voor meer informatie, zie Java-object maken van overgenomen klasse .

Voorbeeld 2: In het onderstaande voorbeeld van overerving is klasse Employee een basisklasse, is klasse Engineer een afgeleide klasse die de klasse Employee uitbreidt en is klasse Test een stuurprogrammaklasse om het programma uit te voeren.

// Java Program to illustrate Inheritance (concise) import java.io.*; // Base or Super Class class Employee {  int salary = 60000; } // Inherited or Sub Class class Engineer extends Employee {  int benefits = 10000; } // Driver Class class Gfg {  public static void main(String args[])  {  Engineer E1 = new Engineer();  System.out.println('Salary : ' + E1.salary  + '
Benefits : ' + E1.benefits);  } }>

Salary : 60000 Benefits : 10000>

Illustratieve afbeelding van het programma:

beperkingen van elektronisch bankieren

In de praktijk, erfenis, en polymorfisme worden samen in Java gebruikt om snelle prestaties en leesbaarheid van code te bereiken.

Java-overervingstypen

Hieronder staan ​​de verschillende soorten overerving die door Java worden ondersteund.

1. Enkelvoudige erfenis
2. Overerving op meerdere niveaus
3. Hiërarchische erfenis
4. Meerdere erfenis
5. Hybride erfenis

1. Enkelvoudige erfenis

Bij enkele overerving wordt een subklasse afgeleid van slechts één superklasse. Het erft de eigenschappen en het gedrag van een eenouderklasse. Soms wordt het ook wel eenvoudige overerving genoemd. In de onderstaande afbeelding is ‘A’ een bovenliggende klasse en ‘B’ een onderliggende klasse. De klasse ‘B’ erft alle eigenschappen van de klasse ‘A’.

Enkelvoudige erfenis

// Java program to illustrate the // concept of single inheritance import java.io.*; import java.lang.*; import java.util.*; // Parent class class One {  public void print_geek()  {  System.out.println('Geeks');  } } class Two extends One {  public void print_for() { System.out.println('for'); } } // Driver class public class Main {  // Main function  public static void main(String[] args)  {  Two g = new Two();  g.print_geek();  g.print_for();  g.print_geek();  } }>

Geeks for Geeks>

2. Overerving op meerdere niveaus

Bij Multilevel Inheritance erft een afgeleide klasse een basisklasse, en fungeert de afgeleide klasse ook als basisklasse voor andere klassen. In de onderstaande afbeelding dient klasse A als basisklasse voor de afgeleide klasse B, die op zijn beurt dient als basisklasse voor de afgeleide klasse C. In Java heeft een klasse geen directe toegang tot de leden van grootouders .

Overerving op meerdere niveaus

// Importing required libraries import java.io.*; import java.lang.*; import java.util.*; // Parent class One class One {  // Method to print 'Geeks'  public void print_geek() {  System.out.println('Geeks');  } } // Child class Two inherits from class One class Two extends One {  // Method to print 'for'  public void print_for() {  System.out.println('for');  } } // Child class Three inherits from class Two class Three extends Two {  // Method to print 'Geeks'  public void print_lastgeek() {  System.out.println('Geeks');  } } // Driver class public class Main {  public static void main(String[] args) {  // Creating an object of class Three  Three g = new Three();    // Calling method from class One  g.print_geek();    // Calling method from class Two  g.print_for();    // Calling method from class Three  g.print_lastgeek();  } }>

Geeks for Geeks>

3. Hiërarchische erfenis

Bij hiërarchische overerving dient één klasse als superklasse (basisklasse) voor meer dan één subklasse. In de onderstaande afbeelding dient klasse A als basisklasse voor de afgeleide klassen B, C en D.

mooiste glimlach

// Java program to illustrate the // concept of Hierarchical inheritance class A {  public void print_A() { System.out.println('Class A'); } } class B extends A {  public void print_B() { System.out.println('Class B'); } } class C extends A {  public void print_C() { System.out.println('Class C'); } } class D extends A {  public void print_D() { System.out.println('Class D'); } } // Driver Class public class Test {  public static void main(String[] args)  {  B obj_B = new B();  obj_B.print_A();  obj_B.print_B();  C obj_C = new C();  obj_C.print_A();  obj_C.print_C();  D obj_D = new D();  obj_D.print_A();  obj_D.print_D();  } }>

Class A Class B Class A Class C Class A Class D>

4. Meervoudige erfenis ( Via interfaces)

In Meerdere erfenissen , kan één klasse meer dan één superklasse hebben en kenmerken van alle bovenliggende klassen overnemen. Houd er rekening mee dat Java dat wel doet niet steun meerdere erfenissen met lessen. In Java kunnen we alleen meerdere overervingen bereiken via Interfaces . In de onderstaande afbeelding is Klasse C afgeleid van interfaces A en B.

Meerdere erfenis

// Java program to illustrate the // concept of Multiple inheritance import java.io.*; import java.lang.*; import java.util.*; interface One {  public void print_geek(); } interface Two {  public void print_for(); } interface Three extends One, Two {  public void print_geek(); } class Child implements Three {  @Override public void print_geek()  {  System.out.println('Geeks');  }  public void print_for() { System.out.println('for'); } } // Drived class public class Main {  public static void main(String[] args)  {  Child c = new Child();  c.print_geek();  c.print_for();  c.print_geek();  } }>

Geeks for Geeks>

5. Hybride erfenis

Het is een combinatie van twee of meer van de bovengenoemde soorten overerving. Omdat Java geen meerdere overervingen met klassen ondersteunt, is hybride overerving met meervoudige overerving ook niet mogelijk met klassen. In Java kunnen we hybride overerving alleen bereiken via Interfaces als we meerdere overerving willen betrekken om hybride overerving te implementeren.
Het is echter belangrijk op te merken dat hybride overerving niet noodzakelijkerwijs uitsluitend het gebruik van meervoudige overerving vereist. Dit kan worden bereikt door een combinatie van overerving op meerdere niveaus en hiërarchische overerving met klassen, en hiërarchische en enkele overerving met klassen. Daarom is het inderdaad mogelijk om hybride overerving te implementeren met alleen klassen, zonder afhankelijk te zijn van meerdere overervingstypen.

Hybride erfenis

Java IS-A-type relatie

IS-A is een manier om te zeggen: dit object is een type van dat object. Laten we eens kijken hoe het trefwoord extends wordt gebruikt om overerving te bereiken.

public class SolarSystem { } public class Earth extends SolarSystem { } public class Mars extends SolarSystem { } public class Moon extends Earth { }>

Op basis van het bovenstaande voorbeeld is, in objectgeoriënteerde termen, het volgende waar:

• SolarSystem is de superklasse van de Earth-klasse.
• SolarSystem is de superklasse van de Mars-klasse.
• Aarde en Mars zijn subklassen van de SolarSystem-klasse.
• Moon is de subklasse van de klassen Earth en SolarSystem.

class SolarSystem { } class Earth extends SolarSystem { } class Mars extends SolarSystem { } public class Moon extends Earth {  public static void main(String args[])  {  SolarSystem s = new SolarSystem();  Earth e = new Earth();  Mars m = new Mars();  System.out.println(s instanceof SolarSystem);  System.out.println(e instanceof Earth);  System.out.println(m instanceof SolarSystem);  } }>

true true true>

Wat kan er gedaan worden in een subklasse?

In subklassen kunnen we leden overnemen zoals ze zijn, ze vervangen, verbergen of aanvullen met nieuwe leden:

• De overgenomen velden kunnen, net als alle andere velden, direct worden gebruikt.
• We kunnen nieuwe velden in de subklasse declareren die niet in de superklasse voorkomen.
• De overgeërfde methoden kunnen direct worden gebruikt zoals ze zijn.
• We kunnen een nieuw schrijven voorbeeld methode in de subklasse die dezelfde handtekening heeft als die in de superklasse, dus overheersend het (zoals in het bovenstaande voorbeeld, toString() methode wordt overschreven).
• We kunnen een nieuw schrijven statisch methode in de subklasse die dezelfde handtekening heeft als die in de superklasse, dus verbergen Het.
• We kunnen nieuwe methoden in de subklasse declareren die niet in de superklasse voorkomen.
• We kunnen een subklasse-constructor schrijven die de constructor van de superklasse aanroept, impliciet of door het trefwoord te gebruiken super .

Voordelen van overerving in Java:

1. Herbruikbaarheid van code: Overerving maakt hergebruik van code mogelijk en vermindert de hoeveelheid code die moet worden geschreven. De subklasse kan de eigenschappen en methoden van de superklasse hergebruiken, waardoor duplicatie van code wordt verminderd.
2. Abstractie: Overerving maakt het mogelijk abstracte klassen te creëren die een gemeenschappelijke interface definiëren voor een groep gerelateerde klassen. Dit bevordert abstractie en inkapseling, waardoor de code gemakkelijker te onderhouden en uit te breiden is.
3. Klassenhiërarchie: Overerving maakt het creëren van een klassenhiërarchie mogelijk, die kan worden gebruikt om objecten uit de echte wereld en hun relaties te modelleren.
4. Polymorfisme: Overerving maakt polymorfisme mogelijk, wat het vermogen van een object is om meerdere vormen aan te nemen. Subklassen kunnen de methoden van de superklasse overschrijven, waardoor ze hun gedrag op verschillende manieren kunnen veranderen.

Nadelen van overerving op Java:

1. Complexiteit: Overerving kan de code complexer en moeilijker te begrijpen maken. Dit geldt vooral als de overervingshiërarchie diep is of als er meerdere overervingen worden gebruikt.
2. Nauwe koppeling: Overerving zorgt voor een nauwe koppeling tussen de superklasse en de subklasse, waardoor het moeilijk wordt om wijzigingen aan te brengen in de superklasse zonder de subklasse te beïnvloeden.

Conclusie

Laten we eens kijken naar enkele belangrijke punten uit het artikel die hieronder worden vermeld:

• Standaard superklasse : Behalve Voorwerp klasse, die geen superklasse heeft, heeft elke klasse slechts één directe superklasse (enkele overerving). Bij afwezigheid van een andere expliciete superklasse is elke klasse impliciet een subklasse van de Object-klasse.
• Superklasse kan er maar één zijn: Een superklasse kan een willekeurig aantal subklassen hebben. Maar een subklasse kan alleen maar een superklasse. Dit komt omdat Java geen meerdere overervingen met klassen ondersteunt. Hoewel er bij interfaces meerdere overervingen worden ondersteund door Java.
• Overervende constructeurs: Een subklasse erft alle leden (velden, methoden en geneste klassen) van zijn superklasse. Constructors zijn geen leden en worden dus niet overgenomen door subklassen, maar de constructor van de superklasse kan vanuit de subklasse worden aangeroepen.
• Erfenis particulier lid: Een subklasse erft niet de private leden van de bovenliggende klasse. Als de superklasse echter openbare of beschermde methoden (zoals getters en setters) heeft voor toegang tot zijn privévelden, kunnen deze ook door de subklasse worden gebruikt.

Veelgestelde vragen over erfenis

1. Wat is Overerving Java?

Overerving is een concept van OOP's waarbij de ene klasse erft van een andere klasse die de methoden en velden van de bovenliggende klasse kan hergebruiken.

2. Wat zijn de 4 soorten overerving in Java?

Er zijn Single, Multiple, Multilevel, Hiërarchisch en Hybride

3. Wat is het nut van een zoekwoord uitbreiden?

Het sleutelwoord Extend wordt gebruikt voor het overerven van de ene klasse naar de andere.

Hoe de applicatie zichtbaar te maken in Android

4. Wat is een voorbeeld van overerving op Java?

Een realistisch voorbeeld van overerving in Java wordt hieronder vermeld:

Beschouw een groep voertuigen. Je moet klassen maken voor Bus, Auto en Vrachtwagen. De methoden brandstofAmount(), capaciteit(), applyBrakes() zullen voor alle drie de klassen hetzelfde zijn.

Gebruikte referenties:

1. Head First Java door Kathy Sierra en Bert Bates
2. Java: een beginnershandleiding door Herbert Schildt
3. Java: de volledige referentie door Herbert Schildt
4. Effectief Java door Joshua Bloch
5. Java: De goede delen van Jim Waldo.