Mana. Mga kalamangan ng mana

"Hello, Amigo! Ngayon narito ang isang paksa sa tingin ko ay marami kang gagamitin. Manang-mana ang sinasabi ko . "

Para sa mga uninitiated, ang programming ay parang magic. Kaya hayaan mo akong magsimula sa isang pagkakatulad ...

Ipagpalagay na ikaw ay isang salamangkero na gustong lumikha ng isang lumilipad na kabayo. Maaari mong subukang gumawa ng isang Pegasus. Ngunit dahil hindi natural na nangyayari ang mga lumilipad na kabayo, talagang mahihirapan ka. Marami kang dapat gawin. Mas madaling magsimula sa isang kabayo at magpatawag ng ilang mga pakpak.

Sa programming, tinatawag namin ang prosesong ito na «mana» . Ipagpalagay na kailangan mong magsulat ng isang napaka-komplikadong klase. Maaari kang gumugol ng mahabang panahon sa pagsusulat ng code mula sa simula, at pagkatapos ay magsagawa ng mahabang pagsubok upang makahanap ng mga bug. Ngunit bakit ito ginagawa sa mahirap na paraan? Mas mainam na tumingin sa paligid at tingnan kung ang klase na iyong hinahanap ay mayroon na?

Sabihin nating nakahanap ka ng klase na nagpapatupad ng 80% ng functionality na kailangan mo. Maaari mo lamang kopyahin ang code nito sa iyong klase. Ngunit iyon ay magkakaroon ng ilang mga kawalan:

1) Ang klase na makikita mo ay maaaring na-compile sa bytecode. Maaaring wala kang access sa source code nito.

2) Maaaring mayroon kang source code para sa klase, ngunit nagtatrabaho ka rin sa isang kumpanya na maaaring kasuhan ng ilang bilyon kung gagamit ka ng kahit 6 na linya ng code ng ibang tao. At pagkatapos ay idedemanda ka nila.

3) Ito ay humahantong sa hindi kinakailangang pagdoble ng maraming code. At kung ang may-akda ng kabilang klase ay nakahanap ng bug at inayos ito, nasa iyo pa rin ang bug.

Mayroong mas eleganteng solusyon na hindi nangangailangan ng pagkuha ng legal na pahintulot sa code ng orihinal na klase. Sa Java, maaari mo lamang ideklara ang ibang klase bilang magulang ng iyong klase. Ito ay katumbas ng pagdaragdag ng code ng klase sa sarili mong klase. Lalabas sa iyong klase ang lahat ng data at pamamaraan ng parent class. Halimbawa, maaari kang magmana mula sa isang «kabayo», magdagdag ng «mga pakpak», at makakuha ng isang «Pegasus».

"Very interesting. Please go on."

"Ang inheritance ay may iba pang gamit din. Ipagpalagay na mayroon kang sampung klase na halos magkapareho. Mayroon silang tugmang data at pamamaraan. Maaari kang lumikha ng espesyal na base class , ilipat ang data (at mga nauugnay na pamamaraan) sa base class , at magkaroon ng sampung klase na iyon. magmana mula rito. Sa madaling salita, para sa bawat klase, ipinapahiwatig mo na mayroon itong parent class, na kilala rin bilang base class."

"Kung paanong ang mga bentahe ng abstraction ay tunay na inihayag lamang kaugnay ng encapsulation, ang mga pakinabang ng inheritance ay pinalaki ng polymorphism. Ngunit sasabihin ko sa iyo ang tungkol doon bukas. Ngayon tingnan natin ang ilang mga halimbawa ng mana."

"Ipagpalagay na nagsusulat tayo ng isang programa ng chess. Kakailanganin natin ang mga klase para sa mga piraso ng chess. Anong mga klase ang imumungkahi mo, Amigo?"

"Hari, Reyna, Obispo, Knight, Rook, at Sanglaan."

"Very good. Wala kang pinalampas."

"At anong data ang iminumungkahi mong iimbak sa mga klaseng ito?"

"Posisyon ng bawat piraso ng board (x at y) at halaga. Pagkatapos ng lahat, ang ilang mga piraso ay mas mahalaga kaysa sa iba."

"At ano ang pagkakaiba ng mga klaseng ito?"

"Nagkakaiba sila sa kung paano nila ginagalaw ang mga piraso. Sa kanilang pag-uugali."

"Oo. Maaari mong tukuyin ang mga ito bilang mga klase tulad nito:"

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
}
}

"Oo, ganyan talaga ang isusulat ko."

"Ngunit tingnan kung paano mo magagamit ang inheritance upang magsulat ng mas kaunting code. Maaari naming ilipat ang magkaparehong mga pamamaraan at data sa isang karaniwang klase. Tawagin natin itong ChessItem. Hindi makatuwirang gumawa ng mga bagay na ChessItem, dahil hindi sila tumutugma sa anumang chess piece. Ngunit ang klase ay lubos na makakatulong:"

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
}
}

"Kawili-wili!"

"Talagang! Ang benepisyo ay lalo na malaki sa mga proyektong naglalaman ng libu-libong iba't ibang mga bagay at daan-daang mga klase. Sa kasong ito, ang maayos na napiling mga klase ay hindi lamang maaaring makabuluhang pasimplehin ang lohika, ngunit bawasan din ang kinakailangang code sa pamamagitan ng isang kadahilanan ng sampu."

"So ano ang kailangan mong gawin para magmana ng klase?"

"Pagkatapos magdeklara ng klase, ginagamit namin ang keyword na ' extends ', na sinusundan ng pangalan ng parent class. Maaari ka lamang magmana mula sa isang klase. "

Ang larawan ay nagpapakita ng isang "baka" na nagmana mula sa isang «baboy». Ang «Baboy» ay nagmamana mula sa «manok», at ang «manok» ay namamana mula sa «itlog». Ang bawat klase ay may isang magulang lamang! Ang ganitong pamana ay hindi palaging lohikal. Kung mayroon ka lamang isang baboy, ngunit talagang kailangan mo ng isang baka, madalas na hindi mapigilan ng mga programmer ang pagnanais na gumawa ng isang «baka» mula sa «baboy».

"Pero paano kung gusto kong magmana sa dalawang klase? May magagawa ba ako?!"

"Hindi talaga. Hindi sinusuportahan ng mga klase ng Java ang maramihang pamana ng pagpapatupad: ang isang klase ay maaari lamang magkaroon ng isang solong magulang na klase. Ngunit mayroong maraming uri ng pamana, na nangangahulugan na ang isang klase ay maaaring magpatupad ng higit sa isang interface. Ito ay bahagyang nagpapagaan sa problema. "

"I see. At ano ang interface?"

"Sasabihin ko sa iyo ang tungkol sa mga interface bukas. Sa ngayon, ipagpatuloy natin ang pagsasaliksik sa mana."