Utforska arv på Java-programmeringsspråket

Arv är ett av kärnkoncepten för objektorienterad programmering. Vid programmering representerar ordet arv en relation där en barnklass antar tillståndet och beteendet hos en föräldraklass.

Syftet med arv i programvaruutveckling är att underlätta återanvändning av säker och pålitlig programvara. En av de största fördelarna med att använda arv är att det eliminerar överflödig kod i dina program.

Hur arv fungerar

Tanken bakom arv är att många klasser eller objekt har några av samma uppsättning attribut och metoder. Därför, i en anda av att producera tillförlitlig programvara, kan nya klasser nu dra från befintliga relaterade klasser och vid behov utöka de befintliga tillstånden och beteenden.

Ett verkligt exempel på hur arv fungerar skulle vara att betrakta frukt. Detta är en bred etikett som fungerar som kapsling av en rad olika artiklar.

Ett äpple är en frukt och också en apelsin. En apelsin är dock inte ett äpple, så du skulle inte ha frukt som en av dina lagervaror om du ägde en butik. Kanske kan du ha en fruktavdelning i ditt lager, och under det avsnittet skulle du ha mer specifika föremål som äpplen och apelsiner.

Så fungerar arv.

Använda arv i Java

Arv kan användas på vilket programmeringsspråk som helst som använder objektorienterad programmering paradigm. Det exakta sättet på vilket arv används är dock beroende av det specifika programmeringsspråket.

Till exempel, C ++ är också ett objektorienterat programmeringsspråk. C ++ stöder så kallad multipel arv, medan Java endast stöder enstaka arv.

Vad detta betyder är att i föräldraklassen i Java kan ha många barnklasser, men varje barnklass kan bara ha en ensamstående föräldraklass (ensamstående arv). Det finns dock ett sätt att uppnå indirekt multipel arv i Java genom att skapa en morföräldrar-, föräldra- och barnrelation.

Skapa föräldraklassen i Java

Processen att välja en överordnad klass från ett dokument med programvarukrav kallas objektorienterad analys. Under denna process används frasen ”är a” ofta för att identifiera möjliga arvsförhållanden. Med hjälp av vårt exempel ovan borde du kunna se att frukt skulle vara vår föräldraklass.

Fruktföräldraklass Exempel

offentlig klass Frukt {
// Variabel deklaration
skyddad strängfrö;
skyddad stränghud Färg;
skyddad strängsmak;
// Standardkonstruktör
offentlig frukt () {
utsäde = "";
skinColor = "";
smak = "";
}
// Primär konstruktör
public Fruit (String seed, String skinColor, String taste) {
this.seed = utsäde;
this.skinColor = skinColor;
detta. smak = smak;
}
// getters och setters
offentlig sträng getSeed () {
returnera utsäde;
}
public void setSeed (String seed) {
this.seed = utsäde;
}
offentlig sträng getSkinColor () {
retur hudFärg;
}
public void setSkinColor (String skinColor) {
this.skinColor = skinColor;
}
public String getTaste () {
retur smak;
}
public void setTaste (Strängsmak) {
detta. smak = smak;
}
// äta metoden
public void eat () {
// allmän kod för hur man äter en frukt
}
// juice-metoden
offentlig tomrumsjuice () {
// allmän kod för hur man saftar en frukt
}
}

En av de mest anmärkningsvärda aspekterna av överordnadsklassen ovan är åtkomstmodifieraren som används med varje variabeldeklaration. Den "skyddade" åtkomstmodifieraren är idealisk för användning i föräldraklasser eftersom den förhindrar att icke-underordnade klasser får tillgång till dataattributen för föräldraklassen.

Längre ner i koden presenteras du för konstruktörer, getters och setter som är allmänna byggstenar för alla Java-klasser. Slutligen introduceras du till två metoder (juice och äta) som skapas i moderklassen i vårt program eftersom de är universella för alla frukter - alla frukter kan ätas och juiceras.

Skapa barnklasser i Java

Barnklasser kallas vanligtvis specialiserade eller härledda klasser eftersom de ärver tillstånd och beteende från en förälder och anpassar ofta dessa attribut för att vara mer specifika.

Fortsätt med vårt exempel bör du kunna se varför apelsin skulle vara en lämplig barnklass i fruktklassen ovan.

Orange barnklassexempel

offentlig klass Orange förlänger frukt {
// variabeldeklaration
privata int supremes;
// standardkonstruktör
public Orange () {
supremes = 0;
}
// primär konstruktör
public Orange (String seed, String skinColor, String taste, int supremes) {
super (utsäde, hudFärg, smak);
this.supremes = supremes;
}
// getters och setters
public int getsupremes () {
returnera supremes;
}
offentliga ogiltiga setsupremes (int supremes) {
this.supremes = supremes;
}
// äta metoden
public void eat () {
// hur man äter en apelsin
}
// juice-metoden
offentlig tomrumsjuice () {
// hur man saftar och apelsin
}
// skalningsmetod
public void peel () {
// hur man skalar en apelsin
}
}

Det finns en skillnad mellan hur en vanlig Java-klassdeklaration ser ut och vad vi har i vår kod ovan. Nyckelordet "utökar" är det som används i Java för att möjliggöra arv.

I vårt exempel ovan utvidgar barnklassen (orange) föräldraklassen (frukt). Därför kan fruktklassens tillstånd och beteende nu nås och ändras av den orange klassen.

Det unika attributet som vår orange klass har identifieras med variabelnamnet supremes (vilket är det officiella namnet för de små segmenten som finns i apelsiner). Det är här specialisering spelar in; inte alla frukter har supremes men alla apelsiner har det, så det är logiskt att reservera variabeln supremes för den orange klassen.

Att lägga till ”skal” -metoden till de befintliga metoderna ”äta” och ”saft” är också logiskt, för även om inte alla frukter kan skalas, är apelsiner ofta skalade.

Du bör komma ihåg att om vi inte hade för avsikt att ändra befintliga "äta" och "juice" -metoder, skulle vi inte behöva inkludera dem i vår orange klass. Metoderna i den orange klassen åsidosätter alla liknande metoder i fruktklassen. Så om alla frukter ätits och juicerats på samma sätt, behöver vi inte skapa dessa metoder i orange klassen.

Rollkonstruktörerna spelar i arv

Som standard ärverklasskonstruktörer ärvda av underklasser. Därför, om ett underordnat klassobjekt skapas betyder det att ett överordnat klassobjekt också skapas automatiskt.

När vi går tillbaka till vårt exempel skapas också ett fruktobjekt varje gång ett nytt orange objekt skapas eftersom en orange är en frukt.

Bakom kulisserna, när ett barnklassobjekt skapas, kallas konstruktören för föräldraklassen först följt av konstruktören för barnklassen. I vår orange barnklass ovan, om ett orange objekt skapas utan några parametrar kommer vår standardfruktklasskonstruktör att anropas, följt av vår standard orange klassentreprenör.

"Super" -metoden i vår primära konstruktör ovan är nödvändig eftersom den anger att den primära konstruktören - och inte standardkonstruktören - för moderfruktklassen ska kallas närhelst ett orange objekt med parametrar är skapad.

Nu kan du använda arv i Java

Från den här artikeln kunde du lära dig vad arv är, hur det fungerar och varför det är ett så viktigt begrepp i programmering. Du kan nu skapa dina arvsrelationer med hjälp av Java-programmeringsspråket. Dessutom vet du nu hur du kan komma runt Java: s enda arvsregel genom att skapa ett morföräldrars förhållande.

Bildkredit: Andreas Wohlfahrt /Pexels

Hur du organiserar din objektorienterade kod med arv

Att få objektorienterad programmering rätt betyder att du behöver veta om arv och hur det kan förenkla kodning och minska fel.

Läs Nästa

Om författaren