Erfenis. Voordelen van overerving

"Hallo, Amigo! Dit is een onderwerp waarvan ik denk dat je het vaak zult gebruiken. Ik heb het over overerving. "

Voor niet-ingewijden is programmeren als magie. Dus laat ik beginnen met een analogie...

Stel dat je een goochelaar bent die een vliegend paard wil maken. Je zou kunnen proberen een Pegasus te toveren. Maar aangezien vliegende paarden niet van nature voorkomen, zul je het heel moeilijk hebben. Je zou een hoop werk te doen hebben. Het zou veel gemakkelijker zijn om met een paard te beginnen en wat vleugels op te roepen.

Bij het programmeren noemen we dit proces «overerving» . Stel dat u een zeer complexe klasse moet schrijven. U kunt veel tijd besteden aan het schrijven van code vanaf nul en vervolgens langdurig testen om bugs te vinden. Maar waarom zou je het op de harde manier doen? Is het beter om rond te kijken en te zien of de klas die je zoekt al bestaat?

Stel dat u een klasse vindt die 80% van de functionaliteit implementeert die u nodig hebt. Je kunt de code gewoon naar je klas kopiëren. Maar dat zou verschillende nadelen hebben:

1) De gevonden klasse is mogelijk al in bytecode gecompileerd. Mogelijk hebt u geen toegang tot de broncode.

2) Je hebt misschien de broncode voor de klas, maar je werkt ook bij een bedrijf dat voor een paar miljard kan worden aangeklaagd als je maar 6 regels code van iemand anders gebruikt. En dan gaan ze je aanklagen.

3) Dit leidt tot onnodige duplicatie van veel code. En als de auteur van de andere klasse een bug vindt en deze repareert, heb je de bug nog steeds.

Er is een elegantere oplossing waarvoor geen wettelijke toestemming nodig is voor de code van de oorspronkelijke klasse. In Java kunt u eenvoudigweg de andere klasse declareren als de ouder van uw klasse. Dit komt overeen met het toevoegen van de code van die klasse aan uw eigen klasse. Alle gegevens en methoden van de bovenliggende klasse verschijnen in uw klasse. U kunt bijvoorbeeld van een «paard» erven, «vleugels» toevoegen en een «Pegasus» krijgen.

"Heel interessant. Ga alsjeblieft verder."

"Overerving heeft ook andere toepassingen. Stel dat je tien klassen hebt die erg op elkaar lijken. Ze hebben overeenkomende gegevens en methoden. Je zou een speciale basisklasse kunnen maken , de gegevens (en bijbehorende methoden) naar de basisklasse kunnen verplaatsen en die tien klassen hebben erven van. Met andere woorden, voor elke klasse geef je aan dat deze een bovenliggende klasse heeft, ook wel een basisklasse genoemd."

"Net zoals de voordelen van abstractie pas echt worden onthuld in verband met inkapseling, worden de voordelen van overerving vergroot door polymorfisme. Maar daar vertel ik je morgen over. Laten we vandaag eens kijken naar een paar voorbeelden van overerving."

'Stel dat we een schaakprogramma schrijven. We hebben lessen nodig voor de schaakstukken. Welke lessen zou jij voorstellen, Amigo?'

"Koning, Koningin, Loper, Ridder, Toren en Pion."

'Heel goed. Je hebt niets gemist.'

"En welke gegevens zou je voorstellen om in deze klassen op te slaan?"

"De positie op het bord van elk stuk (x en y) en waarde. Sommige stukken zijn tenslotte waardevoller dan andere."

"En wat zijn de verschillen tussen deze klassen?"

"Ze verschillen in hoe ze de stukken verplaatsen. In hun gedrag."

"Ja. Je zou ze als klassen als volgt kunnen definiëren:"

class King
{
int x;
int y;
int worth;
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen
{
int x;
int y;
int worth;
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook
{
int x;
int y;
int worth;
void rookMove()
{
//code that defines,
//how the rook moves
}
}

class Knight
{
int x;
int y;
int worth;
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop
{
int x;
int y;
int worth;
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn
{
int x;
int y;
int worth;
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

"Ja, dat is precies hoe ik het zou schrijven."

"Maar kijk eens hoe je overerving kunt gebruiken om minder code te schrijven. We kunnen identieke methoden en gegevens naar een gemeenschappelijke klasse verplaatsen. Laten we het ChessItem noemen. Het heeft geen zin om ChessItem-objecten te maken, omdat ze met geen enkel schaakstuk. Maar de klas zou buitengewoon nuttig zijn:"

class King extends ChessItem
{
void kingMove()
{
//code that defines,
//how the king moves
}
}

class Queen extends ChessItem
{
void queenMove()
{
//code that defines,
//how the queen moves
}
}

class Rook extends ChessItem
{
void rookMove()
{
//code that defines,
//how the rook moves
}
}

 class ChessItem
{
int x;
int y;
int worth;
}
 

class Knight extends ChessItem
{
void knightMove()
{
//code that defines,
//how the knight moves
}
}

class Bishop extends ChessItem
{
void bishopMove()
{
//code that defines,
//how the bishop moves
}
}

class Pawn extends ChessItem
{
void pawnMove()
{
//code that defines,
//how the pawn moves
}
}

"Hoe interessant!"

"Absoluut! Het voordeel is vooral groot in projecten die duizenden verschillende objecten en honderden klassen bevatten. In dit geval kunnen correct gekozen klassen niet alleen de logica aanzienlijk vereenvoudigen, maar ook de vereiste code met een factor tien verminderen."

"Dus wat moet je doen om een ​​klasse te erven?"

“Na het declareren van een klasse gebruiken we het trefwoord ‘ extends ’, gevolgd door de naam van de ouderklasse. Je kunt maar van één klasse erven. ”

De afbeelding toont een "koe" die geërfd is van een "varken". Het «varken» erft van de «kip», en de «kip» erft van het «ei». Elke klas heeft maar één ouder! Zo'n erfenis is niet altijd logisch. Als je alleen een varken hebt, maar je hebt echt een koe nodig, kunnen programmeurs vaak de wens niet weerstaan ​​om van het "varken" een "koe" te maken.

"Maar wat als ik van twee klassen wil erven? Is er iets dat ik kan doen?!"

"Niet echt. Java-klassen ondersteunen geen meervoudige overerving van implementatie: een klasse kan slechts één bovenliggende klasse hebben. Maar er is meervoudige overerving van het type, wat betekent dat een klasse meer dan één interface kan implementeren. Dit verzacht het probleem enigszins. "

"Ik snap het. En wat is een interface?"

'Morgen vertel ik je meer over interfaces. Laten we ons voorlopig verder verdiepen in overerving.'