Ano ang mga interface

Ang interface ay isang pampubliko, karaniwang tinatanggap na kontrata (kasunduan) na naglalarawan ng ilang gawi. Ano ang kailangan nila? Halimbawa, sabihin nating mayroon tayong link na tumuturo sa isang listahan ng mga string. Sabihin nating maraming elemento ang idinaragdag sa listahang ito sa simula, at pagkatapos ay ang buong listahan ay naproseso nang isang beses. Sabihin nating nagpasya kaming sundin ang kilalang rekomendasyon at gamitin ang klaseArrayList:

ArrayList<String> list = new ArrayList<>();

Nagsulat kami ng pag-uugali ng programa sa 100,500 linya ng code na gumamit ng listahan ng mga string na ito, at gumamit ng mga pamamaraang tukoy sa klase upang i-optimize ang pagganap ArrayList. Halimbawa ensureCapacity() . Hangga't ang mga linya ay idinagdag sa dulo ng listahan, lahat ay gumagana nang maayos at mabilis. Ngunit ngayon kailangan nating i-reorient ang ating programa sa isang bahagyang naiibang uri ng trabaho, kung saan ang mga linya ay pangunahing idinaragdag sa simula ng listahan. Para sa ganitong uri ng pagkarga ito ay mas angkop LinkedList. Ngunit kung gusto naming isalin ang aming programa ng 100,500 linya ng code sa mga riles LinkedList, kakailanganin naming hanapin at alisin ang paggamit ng mga partikular ArrayListna pamamaraan, marahil sa ilang lugar ay lubos na nagbabago ang lohika ng mga indibidwal na seksyon ng programa. Kung ginamit lang namin ang mga pamamaraan na magagamit sa parehong ArrayList, at sa LinkedList, kung gayon hindi namin kailangang gawin ito. Maaari lamang nating baguhin ang isang linya ng code - ang deklarasyon ng listahan:

LinkedList<String> list = new LinkedList<>();

Mapapansin natin na magiging mas maginhawang ilagay ang deklarasyon ng mga karaniwang pamamaraan para sa mga klaseng ito sa isang ancestor class, posibleng abstract, halimbawa AbstractList. Sa kasong ito, maaari naming ideklara ang aming listahan tulad nito:

AbstractList<String> list = new ArrayList<>();

At maaari naming mabilis na ilipat ang pagpapatupad tulad nito:

AbstractList<String> list = new LinkedList<>();

Ngunit sa kasong ito, ang mga klase na magagamit namin sa aming programa ay limitado lamang sa mga inapo ng klase AbstractList, kahit na may mas angkop na mga klase na hindi mga inapo ng klase AbstractList, ngunit may parehong mga pamamaraan na may parehong pag-uugali. Anong gagawin ko? Ito ang dahilan kung bakit naimbento ang mga interface . Ang isang interface ay isang kumbensyon tungkol sa isang hanay ng mga pamamaraan at ang kanilang pag-uugali na ganap na walang kaugnayang mga klase ay maaaring gumawa, na nagpapahintulot sa alinman sa mga ito na ma-reference ng isang solong sanggunian. Halimbawa tulad nito:

List<String> list;
list = new ArrayList<>();
list = new LinkedList<>();
list = new AnotherListClass<>();

Kahit na AnotherListClassang mga klase ay walang mga karaniwang klase ng ninuno, ArrayListmaliban sa . Ang isang magandang halimbawa ng isang interface ay ang pagpipiloto ng isang kotse - ang isang kotse ay may manibela, mga pedal at isang gearbox. Sa karamihan ng mga kotse, ang mga elementong ito ay sumusunod sa parehong kumbensyon ng pag-uugali. Halimbawa, kung iikot mo ang manibela nang pakaliwa, ang sasakyan ay liliko sa kaliwa sa halip na bibilis, anuman ang gawa nito. Kung alam mo kung paano gamitin ang mga kontrol na ito, madali mong mahahawakan ang anumang kotse, anuman ang modelo, taon, gawa o uri ng makina nito. Bukod dito, maiisip ng isang tao ang isang sitwasyon kung saan ang isang ganap na magkakaibang uri ng transportasyon (halimbawa, isang sasakyang pangalangaang) ay may parehong interface ng kontrol tulad ng mga kotse. Kung alam mo kung paano magmaneho ng kotse, nahanap mo ang iyong sarili sa upuan ng piloto ng naturang barko, maiiwasan mong mawala sa sitwasyong ito. Ulitin natin muli:LinkedListObject

• Ang interface ay isang kontrata (kasunduan) tungkol sa pag-uugali.
• Maraming mga klase, kahit na ang mga hindi nauugnay sa pamamagitan ng mana, ay maaaring magpahayag na sila ay sumasang-ayon na sumunod sa kontratang ito (implementasyon ng interface).
• Ang paglalagay ng paglalarawan ng pag-uugali sa isang hiwalay na interface ay napaka-maginhawa, dahil pinapataas nito ang flexibility ng code, na nagpapahintulot sa iyo na ilipat ang pagpapatupad (klase na nagpapatupad ng interface) ng interface sa mga klase na hindi nauugnay sa mana.