Onderzoek naar overerving in de programmeertaal van Java

Overerving is een van de kernconcepten van objectgeoriënteerd programmeren. Bij het programmeren vertegenwoordigt het woord overerving een relatie waarin een onderliggende klasse de toestand en het gedrag van een bovenliggende klasse aanneemt.

Het doel van overerving bij softwareontwikkeling is om het hergebruik van veilige en betrouwbare software te vergemakkelijken. Een van de belangrijkste voordelen van het gebruik van overerving is dat het overtollige code in uw programma's elimineert.

Hoe overerving werkt

Het idee achter overerving is dat veel klassen of objecten dezelfde set attributen en methoden hebben. Daarom, in de geest van het produceren van betrouwbare software, kunnen nieuwe klassen nu putten uit reeds bestaande gerelateerde klassen en, indien nodig, bestaande toestanden en gedragingen uitbreiden.

Een realistisch voorbeeld van hoe overerving werkt, zou zijn om rekening te houden met fruit. Dit is een breed label dat dient om een ​​reeks verschillende items in te kapselen.

Een appel is een vrucht en een sinaasappel ook. Een sinaasappel is echter geen appel, dus u zou geen fruit als een van uw voorraadartikelen hebben als u een winkel had. Misschien zou je een fruitsectie in je inventaris kunnen hebben, en onder die sectie zou je meer specifieke items hebben, zoals appels en sinaasappels.

Dat is hoe overerving werkt.

Overerving gebruiken in Java

Overerving kan worden gebruikt in elke programmeertaal die de objectgeoriënteerd programmeerparadigma. De exacte manier waarop overerving wordt gebruikt, is echter afhankelijk van de specifieke programmeertaal.

Bijvoorbeeld, C ++ is ook een objectgeoriënteerde programmeertaal. C ++ ondersteunt wat bekend staat als meervoudige overerving, terwijl Java alleen enkele overerving ondersteunt.

Dit betekent dat in Java een bovenliggende klasse veel onderliggende klassen kan hebben, maar elke onderliggende klasse kan slechts één bovenliggende klasse hebben (enkele overerving). Er is echter een manier om indirecte meervoudige overerving in Java te bereiken door een grootouder-, ouder- en kindrelatie te creëren.

De bovenliggende klasse maken in Java

Het proces van het selecteren van een bovenliggende klasse uit een document met softwarevereisten staat bekend als objectgeoriënteerde analyse. Tijdens dit proces wordt de uitdrukking "is a" vaak gebruikt om mogelijke overervingsrelaties te identificeren. Aan de hand van ons voorbeeld hierboven zou je moeten kunnen zien dat fruit onze ouderklasse zou zijn.

Fruit Parent Class Voorbeeld

openbare klasse Fruit {
// Variabele declaratie
beschermd String-zaad;
beschermde String skinColor;
beschermde snaarsmaak;
// Standaard Constructor
openbaar Fruit () {
seed = "";
skinColor = "";
smaak = "";
}
// Primaire constructor
openbaar Fruit (String seed, String skinColor, String smaak) {
this.seed = zaad;
this.skinColor = skinColor;
this.taste = smaak;
}
// getters en setters
openbare String getSeed () {
terug zaad;
}
public void setSeed (String seed) {
this.seed = zaad;
}
openbare String getSkinColor () {
terug skinColor;
}
public void setSkinColor (String skinColor) {
this.skinColor = skinColor;
}
openbare String getTaste () {
terugkeer smaak;
}
public void setTaste (String-smaak) {
this.taste = smaak;
}
// eet methode
openbare leegte eten () {
// algemene code voor het eten van fruit
}
// juice-methode
openbare leegte juice () {
// algemene code voor het persen van fruit
}
}

Een van de meest opvallende aspecten van de bovenliggende klasse hierboven is de toegangsmodificator die wordt gebruikt bij elke variabele declaratie. De "beschermde" toegangsmodificator is ideaal voor gebruik in bovenliggende klassen omdat deze voorkomt dat niet-onderliggende klassen toegang krijgen tot de gegevensattributen van de bovenliggende klasse.

Verderop in de code maak je kennis met constructors, getters en setters die algemene bouwstenen zijn voor elke Java-klasse. Ten slotte maakt u kennis met twee methoden (sap en eten) die zijn gemaakt in de bovenliggende klasse van ons programma omdat ze universeel zijn voor alle soorten fruit - alle soorten fruit kunnen worden gegeten en geperst.

Kinderklassen maken in Java

Onderliggende klassen worden meestal gespecialiseerde of afgeleide klassen genoemd omdat ze de toestand en het gedrag van een ouder erven, en deze kenmerken vaak aanpassen om specifieker te zijn.

Als we doorgaan met ons voorbeeld, zou je moeten kunnen zien waarom oranje een geschikte kinderklasse zou zijn van de bovenstaande fruitklasse.

Orange Child Class Voorbeeld

openbare klasse Orange breidt Fruit {
// variabele declaratie
privé int supremes;
// standaard constructor
openbaar Oranje () {
supremes = 0;
}
// primaire constructor
public Orange (String seed, String skinColor, String smaak, int supremes) {
super (zaad, skinColor, smaak);
this.supremes = supremes;
}
// getters en setters
openbare int getsupremes () {
terugkeer supremes;
}
openbare leegte setsupremes (int supremes) {
this.supremes = supremes;
}
// eet methode
openbare leegte eten () {
// hoe je een sinaasappel eet
}
// juice-methode
openbare leegte juice () {
// hoe sap en sinaasappel te maken
}
// schil methode
openbare leegte schil () {
// hoe je een sinaasappel schilt
}
}

Er is een verschil tussen hoe een normale Java-klassedeclaratie eruitziet en wat we in onze bovenstaande code hebben. Het sleutelwoord "extends" wordt in Java gebruikt om overerving mogelijk te maken.

In ons voorbeeld hierboven breidt de child class (oranje) de parent class (fruit) uit. Daarom kunnen de status en het gedrag van de fruitklasse nu worden geopend en gewijzigd door de oranje klasse.

Het unieke kenmerk dat onze oranje klasse heeft, wordt geïdentificeerd met de variabelenaam supremes (wat de officiële naam is voor de kleine segmenten die in sinaasappels worden gevonden). Dit is waar specialisatie om de hoek komt kijken; niet alle vruchten hebben supremes, maar alle sinaasappels, dus het is logisch om de supremes-variabele te reserveren voor de oranjeklasse.

Het toevoegen van de "schil" -methode aan de reeds bestaande "eet" en "sap" -methoden is ook logisch, want hoewel niet alle vruchten kunnen worden geschild, worden sinaasappels vaak geschild.

Houd er rekening mee dat als we niet van plan waren de bestaande "eten" en "sap" -methoden te wijzigen, we ze niet in onze sinaasappelklasse zouden hoeven opnemen. De methoden in de oranje klasse hebben voorrang op gelijkaardige methoden in de fruitklasse. Dus als al het fruit op dezelfde manier zou worden gegeten en geperst, zouden we deze methoden niet in de sinaasappelklasse hoeven te maken.

De rolconstructeurs spelen in erfenis

Standaard worden constructors van bovenliggende klassen overgenomen door onderliggende klassen. Als er dus een kindklasseobject wordt gemaakt, betekent dit dat er ook automatisch een bovenliggend klasseobject wordt gemaakt.

Terugkomend op ons voorbeeld, elke keer dat een nieuw oranje object wordt gemaakt, wordt er ook een fruitobject gemaakt omdat een sinaasappel een vrucht is.

Wanneer achter de schermen een kindklasseobject wordt gemaakt, wordt eerst de constructor van de bovenliggende klasse aangeroepen, gevolgd door de constructor van de kindklasse. Als in onze oranje child-klasse hierboven een oranje object wordt gemaakt zonder parameters, wordt onze standaard fruitklasse-constructor aangeroepen, gevolgd door onze standaard oranje class-aannemer.

De "super" -methode in onze primaire constructor hierboven is nodig omdat deze specificeert dat de primaire constructor — en niet de standaardconstructor - van de bovenliggende fruitklasse moet worden aangeroepen wanneer een oranje object met parameters is gemaakt.

Nu kunt u overerving in Java gebruiken

Uit dit artikel heb je kunnen leren wat overerving is, hoe het werkt en waarom het zo'n belangrijk concept is bij programmeren. U kunt nu uw overervingsrelaties maken met behulp van de programmeertaal Java. Bovendien weet u nu hoe u de enige overervingsregel van Java kunt omzeilen door een grootouderrelatie te creëren.

Beeldcredits: Andreas Wohlfahrt /Pexels

Hoe u uw objectgeoriënteerde code kunt ordenen met overerving

Objectgeoriënteerd programmeren op de juiste manier betekent dat u meer moet weten over overerving en hoe het codering kan vereenvoudigen en fouten kan verminderen.

Lees Volgende

Over de auteur