Utforskar arv på Java -programmeringsspråket

Utforskar arv på Java -programmeringsspråket

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





Syftet med arv inom mjukvaruutveckling är att underlätta återanvändning av säker och pålitlig programvara. En av de stora fördelarna med att använda arv är att det eliminerar redundant kod i dina program.





Windows kan inte kommunicera med enheten

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 kan nya klasser nu i andan att producera tillförlitlig programvara dras från redan existerande relaterade klasser och vid behov utöka befintliga tillstånd och beteenden.





Ett verkligt exempel på hur arv fungerar skulle vara att överväga frukter. Detta är en bred etikett som tjänar till att inkapsla en rad olika objekt.

Ett äpple är en frukt och det är en apelsin också. 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 ett fruktavsnitt i din inventering, 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 i alla programmeringsspråk som använder det objektorienterade programmeringsparadigmet. 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 det som kallas multipelarv, medan Java bara stöder ett enda arv.

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





Skapa föräldraklassen i Java

Processen att välja en föräldraklass från ett dokument med programvarukrav kallas objektorienterad analys. Under denna process används ofta frasen a för att identifiera möjliga arvsrelationer. Utifrån vårt exempel ovan borde du kunna se att frukt skulle vara vår föräldraklass.

Fruktföräldraklass Exempel


public class Fruit {
//Variable Declaration
protected String seed;
protected String skinColor;
protected String taste;
//Default Constructor
public Fruit(){
seed = '';
skinColor ='';
taste ='';
}
//Primary Constructor
public Fruit(String seed, String skinColor, String taste){
this.seed = seed;
this.skinColor = skinColor;
this.taste = taste;
}
//getters and setters
public String getSeed() {
return seed;
}
public void setSeed(String seed) {
this.seed = seed;
}
public String getSkinColor() {
return skinColor;
}
public void setSkinColor(String skinColor) {
this.skinColor = skinColor;
}
public String getTaste() {
return taste;
}
public void setTaste(String taste) {
this.taste = taste;
}
//eat method
public void eat(){
//general code on how to eat a fruit
}
//juice method
public void juice() {
//general code on how to juice a fruit
}
}

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

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

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 ofta anpassar dessa attribut för att vara mer specifika.

Om vi ​​fortsätter med vårt exempel bör du kunna se varför apelsin skulle vara en lämplig barnklass i fruktklassen ovan.

Orange barnklass Exempel


public class Orange extends Fruit{
//variable declaration
private int supremes;
//default constructor
public Orange() {
supremes = 0;
}
//primary constructor
public Orange(String seed, String skinColor, String taste, int supremes){
super(seed, skinColor, taste);
this.supremes = supremes;
}
//getters and setters
public int getsupremes() {
return supremes;
}
public void setsupremes(int supremes) {
this.supremes = supremes;
}
//eat method
public void eat(){
//how to eat an orange
}
//juice method
public void juice() {
//how to juice and orange
}
//peel method
public void peel(){
//how to peel an orange
}
}

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

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

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

Att lägga till skalmetoden till de redan existerande ät- och juicemetoderna är också logiskt eftersom även om inte alla frukter kan skalas, apelsiner ofta skalas.

Du bör komma ihåg att om vi inte hade för avsikt att ändra de befintliga mat- och saftmetoderna skulle vi inte behöva inkludera dem i vår apelsinklass. Metoderna i apelsinklassen åsidosätter alla liknande metoder i fruktklassen. Så om alla frukter äts och saftas på samma sätt, skulle vi inte behöva skapa dessa metoder i den orange klassen.

Rollkonstruktörerna spelar i arv

Som standard ärvs överordnade klasskonstruktörer ärvda av barnklasser. Om ett barnklassobjekt skapas betyder det därför att ett föräldraklassobjekt också skapas automatiskt.

För att gå tillbaka till vårt exempel, varje gång ett nytt orange objekt skapas skapas ett fruktobjekt också eftersom en apelsin ä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 standard fruktklasskonstruktör att kallas, följt av vår standard orange klassentreprenör.

Supermetoden i vår primära konstruktör ovan är nödvändig eftersom den specificerar att den primära konstruktorn - och inte standardkonstruktorn - för den överordnade fruktklassen ska anropas när som helst ett orange objekt med parametrar skapas.

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 inom programmering. Du kan nu skapa dina arvsrelationer med programmeringsspråket Java. Dessutom vet du nu hur du kan komma runt Java: s enda arvsregel genom att skapa en morförälderrelation.

Bildkredit: Andreas Wohlfahrt / Pexels

Dela med sig Dela med sig Tweet E-post Hur man organiserar din objektorienterade kod med arv

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

Läs Nästa
Relaterade ämnen
  • Programmering
  • Java
  • Objektorienterad programmering
Om författaren Kadeisha Kean(21 artiklar publicerade)

Kadeisha Kean är en fullstack mjukvaruutvecklare och teknisk/teknikförfattare. Hon har den distinkta förmågan att förenkla några av de mest komplexa tekniska begreppen; producerar material som lätt kan förstås av någon nybörjare inom teknik. Hon brinner för att skriva, utveckla intressant programvara och resa runt i världen (genom dokumentärer).

Mer från Kadeisha Kean

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera