1. Ipinapakilala ang mga interface
Ngayon ang araw mo para sa kaalaman. Ang isa pang bago at kawili-wiling paksa ay ang mga interface.
Ang konsepto ng isang interface ay ang bata ng mga prinsipyo ng abstraction at polymorphism. Ang isang interface ay halos kapareho sa isang abstract na klase, kung saan ang lahat ng mga pamamaraan ay abstract. Ito ay ipinahayag sa parehong paraan bilang isang klase, ngunit ginagamit namin ang interface
keyword.
interface Feline
{
void purr();
void meow();
void growl();
}
Narito ang ilang kapaki-pakinabang na katotohanan tungkol sa mga interface:
1. Pagdedeklara ng interface
interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}
- Sa halip na
class
keyword, isinusulat namin anginterface
. - Naglalaman lamang ito ng mga abstract na pamamaraan (huwag isulat ang
abstract
keyword) - Sa katunayan, ang mga interface ay may lahat
public
ng mga pamamaraan
Ang isang interface ay maaari lamang magmana ng mga interface. Ngunit ang isang interface ay maaaring magkaroon ng maraming mga magulang. Ang isa pang paraan upang sabihin ito ay ang pagsasabi na ang Java ay may maraming pamana ng mga interface. Mga halimbawa:
interface Piece extends Drawable, HasValue
{
int getX();
int getY();
}
3. Pagpapamana ng mga klase mula sa mga interface
Ang isang klase ay maaaring magmana ng maraming interface (mula lamang sa isang klase). Ginagawa ito gamit ang implements
keyword. Halimbawa:
abstract class ChessItem implements Drawable, HasValue
{
private int x, y, value;
public int getValue()
{
return value;
}
public int getX()
{
return x;
}
public int getY()
{
return y;
}
}
Ang klase ng ChessItem ay idineklara na abstract: ipinapatupad nito ang lahat ng minanang pamamaraan maliban sa draw
. Sa madaling salita, ang ChessItem
klase ay naglalaman ng isang abstract na pamamaraan — draw()
.
Ang teknikal na kahulugan ng extends
at implements
mga keyword ay pareho: pareho ay mana. Ang pagkakaiba ay ginawa upang mapabuti ang pagiging madaling mabasa ng code. Sinasabi rin namin na ang mga klase ay minana (sa pamamagitan ng extends
) at ang mga interface ay ipinatupad (sa pamamagitan ng implements
)
4. Mga variable
Narito ang pinakamahalagang bagay: ang mga ordinaryong variable ay hindi maaaring ideklara sa mga interface (bagaman maaari ang mga static).
Ngunit bakit kailangan natin ng mga interface? Kailan sila ginagamit? Ang mga interface ay may dalawang malakas na pakinabang sa mga klase:
2. Paghihiwalay sa "paglalarawan ng mga pamamaraan" mula sa kanilang pagpapatupad.
Noong nakaraan, sinabi namin na kung gusto mong payagan ang mga pamamaraan ng iyong klase na matawag mula sa ibang mga klase, kung gayon ang iyong mga pamamaraan ay kailangang markahan ng public
keyword. Kung gusto mong tawagin ang ilan sa mga pamamaraang iyon mula lamang sa loob ng iyong klase, kailangan mong markahan ang mga ito ng private
keyword. Sa madaling salita, hinahati namin ang mga pamamaraan ng klase sa dalawang kategorya: "para magamit ng lahat" at "para lamang sa aming sariling paggamit".
Nakakatulong ang mga interface na palakasin pa ang dibisyong ito. Gagawa kami ng espesyal na "klase para magamit ng lahat" pati na rin ang pangalawang klase "para lang sa sarili naming gamit", na magmamana ng unang klase. Narito ang halos kung ano ang magiging hitsura nito:
dati | Pagkatapos |
---|---|
|
|
|
|
Hinati namin ang aming klase sa dalawa: isang interface at isang klase na nagmamana ng interface . At ano ang kalamangan dito?
Maraming iba't ibang klase ang maaaring magpatupad (magmana) ng parehong interface. At ang bawat isa ay maaaring magkaroon ng sariling pag-uugali. Halimbawa, ArrayList
LinkedList
ay dalawang magkaibang pagpapatupad ng List
interface.
Kaya, itinatago namin hindi lamang ang iba't ibang mga pagpapatupad, kundi pati na rin ang klase ng pagpapatupad mismo (dahil kailangan lang namin ang interface sa code). Nagbibigay-daan ito sa amin na maging napaka-flexible: habang tumatakbo ang program, maaari naming palitan ang isang bagay ng isa pa, binabago ang gawi ng isang bagay nang hindi naaapektuhan ang lahat ng klase na gumagamit nito.
Ito ay isang napakalakas na pamamaraan kapag pinagsama sa polymorphism. Sa ngayon, malayong malinaw kung bakit mo ito dapat gawin. Kailangan mo munang makatagpo ng mga programa na may dose-dosenang o daan-daang mga klase upang maunawaan na ang mga interface ay maaaring gawing mas madali ang iyong buhay kaysa wala sila.
3. Maramihang mana
Sa Java, ang lahat ng klase ay maaari lamang magkaroon ng isang parent class. Sa iba pang mga programming language, ang mga klase ay kadalasang maaaring magkaroon ng maraming klase ng magulang. Ito ay napaka-maginhawa, ngunit nagdudulot din ng maraming problema.
Ang mga tagalikha ng Java ay dumating sa isang kompromiso: ipinagbawal nila ang maramihang pamana ng mga klase, ngunit pinapayagan ang maramihang pamana ng mga interface. Maaaring magkaroon ng maraming interface ng magulang ang isang interface. Ang isang klase ay maaaring magkaroon ng maraming interface ng magulang ngunit isang parent class lamang.
Bakit nila ipinagbawal ang maramihang pamana ng mga klase ngunit pinapayagan ang maramihang pamana ng mga interface? Dahil sa tinatawag na diamond inheritance problem:

Kapag ang B class ay nagmana ng A class, wala itong alam tungkol sa C at D na klase. Kaya ginagamit nito ang mga variable ng A class ayon sa nakikita nitong akma. Ganoon din ang ginagawa ng C class: ginagamit nito ang mga variable ng A class, ngunit sa ibang paraan. At ang lahat ng ito ay nagreresulta sa isang salungatan sa klase ng D.
Tingnan natin ang sumusunod na simpleng halimbawa. Sabihin nating mayroon tayong 3 klase:
class Data
{
protected int value;
}
class XCoordinate extends Data
{
public void setX (int x) { value = x;}
public int getX () { return value;}
}
class YCoordinate extends Data
{
public void setY (int y) { value = y;}
public int getY () { return value; }
}
Iniimbak ng klase ng Data ang value
variable. Ang XCoordinate descendant class nito ay gumagamit ng variable na iyon para iimbak ang x
value, at YCoordinate
ginagamit ito ng descendant class para iimbak ang y
value.
At ito ay gumagana. Hiwalay. Ngunit kung gusto nating mamanahin ng XYCoordinates class ang XCoordinate
at YCoordinate
mga klase, pagkatapos ay makakakuha tayo ng sirang code. Ang klase na ito ay magkakaroon ng mga pamamaraan ng mga ninuno nitong klase, ngunit hindi ito gagana nang tama, dahil mayroon silang pareho value variable
.
Ngunit dahil ang mga interface ay hindi maaaring magkaroon ng mga variable, hindi sila maaaring magkaroon ng ganitong uri ng salungatan. Alinsunod dito, pinapayagan ang maramihang pagmamana ng mga interface.
GO TO FULL VERSION