Interface sa Java

Ako ay isang masamang mananalaysay kung wala akong layunin na ipaliwanag ang isang bagay na hindi maintindihan sa isang taong may partikular na kahilingan, kaya naiintindihan ko ang mga simpleng bagay, at sa isang bagay ay isusulat ko ang tungkol dito. Hindi ko sinusunod ang halimbawa ng pagtuturo ng JavaRush ng unang pagtatanong at pagkatapos ay sasabihin sa iyo kung paano ito gagawin. Ako ay isang tagasuporta ng unang pagsasabi, at pagkatapos ay nagtatanong, tulad ng pagsasabi, unang nagpapakita, at pagkatapos ay nagpapaliwanag. BS: Mga Aksyon == pag-uugali, kunin ang mga ito bilang kasingkahulugan, ang mga aksyon ay mas naiintindihan nang tama, ito ay palaging isang bagay na aktibo, at ang pag-uugali ay maaaring hindi magpakita ng anuman.

interface - interface

Ano ito? Halimbawang listahan ng interface (na may mga generic):

public interface Store<T, ID> {
    void add(T t);
    void update(T t, ID i);
    void delete(ID i);
    T findOne(ID i);
    List<T> findAll();
}

Karaniwang crud (mula sa CRUD: Lumikha, Magbasa, Mag-update, Magtanggal) na interface. Huwag mag-alala, ang lahat ay medyo simple. Ang interface na ito ay nangangahulugan na ang pagtatrabaho sa maraming mga database ay batay sa sumusunod na prinsipyo: kailangan mong magdagdag ng isang tala, mag-update ng isang tala, magtanggal at hanapin ang lahat ng mga talaan. Malalaman mo ito nang 100 beses at isusulat mo ang halos parehong interface sa iyong sarili sa parehong bilang ng beses. Ito ay itinalagang pampubliko dahil dapat itong ipatupad ng klase. Ano ang ibig sabihin ng ipatupad ng isang klase ? Ang lahat ay napaka-simple: dapat itong ilarawan ang lahat ng mga pamamaraan ng interface. Ang pinakasimpleng halimbawa ng pagpapatupad sa isang klase:

void add (T t) {
	bookstore.add(t);
}

Sa halip na T t, isang partikular na generic ang papalitan. Sa madaling sabi, ito ang TYPE ng isang variable, kaya naman madalas itong tinutukoy bilang T = Type. Sa aming halimbawa, sabihin nating maaaring ganito:

void add (Book book) {
	bookstore.add(book);
}

Naturally, sa halip ng Book book maaari mong palitan ang anumang variable na kailangan mo para sa iyong pagpapatupad. Upang maunawaan, maaari mong isipin na ang T = Object, at dahil ang lahat sa Java ay Object, maaari mo ring tukuyin ang alinman sa iyong mga klase/variable doon. Ang tanging problema ay lilitaw sa ibang pagkakataon - mga pagbubukod kung ang klase ay zero, atbp. Sa sarili nitong mga salita, ito ay isang tiyak na istraktura ng programa na tumutukoy sa mga ugnayan sa pagitan ng mga bagay sa pamamagitan ng paghahati sa mga ito sa ilang mga bahagi ng pag-uugali. Ang layunin ng isang interface ay upang tukuyin ang pag-andar para sa pagpapatupad ng isang klase. Iyon ay, isang paglalarawan ng mga lagda ng pamamaraan. Sa loob ng interface ay may mga pangalan ng mga pamamaraan na nagbabalik at mga halaga ng pag-input, at iyon lang. Well, maaari ka pa ring magtalaga ng ilang mga variable doon, ngunit sila ay agad na nagiging pampublikong static final, at maaaring ma-access mula sa anumang bahagi ng programa. Ang interface ay naglalarawan ng mga aksyon, at samakatuwid ang parehong mga aksyon ay nakapaloob dito, i.e. mga function o pamamaraan. Bakit kailangan ito? Ano ang pinapasimple nito o anong mga pakinabang ang ibinibigay nito? Pagpapasimple ng paglalarawan ng mga aksyon at pag-uugali. Sinasabi namin kung ano ang gagawin, ngunit ipinapatupad ng bawat klase kung paano ito gagawin mismo. Makatipid ng oras sa malalaking proyekto. Ang mga interface ay nilikha sa mga sitwasyon kung saan alam nating kailangan nating gawin ang ilang gawain, ngunit kung paano ito gagawin ay maaaring mag-iba. Inilalarawan ng interface ang mga pangalan ng mga aksyon - ito ay simpleng direksyon ng ilang abstraction. Bagama't maaaring mayroon ding mga interface na walang mga pamamaraan at field, tulad ng mga marker tulad ng Cloneable, Remote, atbp. Kunin natin ang paboritong halimbawa ng kotse ng lahat. Ang interface sa loob nito ay maglalarawan ng mga posibleng aksyon ng kotse, pag-ikot ng manibela o direksyon ng paggalaw, pagtaas ng bilis, natitirang gasolina, atbp. Iyon ay, ang parehong mga aksyon na maaaring magkaroon ng ganap na anumang kotse. Sa madaling salita, bumababa tayo sa gubat ng degradasyon sa pinakamababang antas ng paglikha ng pinakaunang kotse at gamit ang sarili nating talino, alam natin kung paano ito nilikha at kung ano ang mayroon ito. Naturally, inilalarawan namin ito sa abstract at para lamang sa mga aksyon. Ano ang mayroon ang pinakaunang kotse? Mayroon bang manibela? Ito ay, ibig sabihin ay lumiliko ito sa isang lugar, ang direksyon ng manibela/galaw. Mayroon bang mga gulong? Oo, nangangahulugan iyon na nagmamaneho ako sa ilang bilis, isang pagbabago sa bilis. Iyan ang buong interface. Ngunit sa pangkalahatan, ang mga interface ay nilikha para sa ilang pagpapatupad ng ilang mga aksyon. Yung. sumusulat kami ng isang programa para sa mga mas tiyak kaysa sa anumang bagay na maiisip mo. Samakatuwid, ang mga interface mismo ay maglalaman ng mas malinaw at mas tiyak na mga pamamaraan. Siyempre magiging abstract sila hangga't maaari. Ang mga interface ay maaaring mamana mula sa isa't isa bilang mga klase.

interface MyInterface extends NotMyinterface;

Ang mga interface ay ipinatupad sa mga klase. Maaari kang magpatupad ng maraming interface hangga't gusto mo. Hindi tulad ng mana, magmana sa isa lamang.

class NewClass extends OldClass implements MyInterface, NotMyinterface;

Yung. nakagawa kami ng ilang mga aksyon, binigyan sila ng mga pangalan, data ng pag-input, pagbabalik ng data, isinulat ang lahat ng ito sa interface, pagkatapos ay lumikha ng isang klase at idinagdag ang aming interface sa klase na ito, i.e. ipinatupad ang aming interface sa klase na ito. Dagdag pa, ang lahat ng mga pamamaraan/function na inilarawan sa interface ay dapat may pagpapatupad. Maaari itong gawin nang direkta sa interface mismo sa pamamagitan ng pagdaragdag ng salitang default bago ang pamamaraan at direktang pagsulat ng pagpapatupad sa pamamaraan, tulad ng isang klase. Naging posible ito sa bersyon 8 ng Java. Maaari rin itong gawin sa isang klase na magpapatupad ng interface na ito. Well, isinulat namin ang interface, ipinatupad ito sa klase, inilunsad ang pagpapatupad sa klase, maaari naming patakbuhin ito at subukan ito. Maaari mo ring basahin sa mga interface ang tungkol sa:

• Mga static na pamamaraan.
• Mga pribadong pamamaraan. (ulitin ang code)
• Mga variable/Constant.
• Mga nested na interface.

Ngunit mas mahusay na gawin ito sa ibang pagkakataon, at nakakapinsala din na punan ang iyong ulo ng labis. Kawili-wiling tanong, ano ang Volvo? Klase o Interface?

line1: Volvo v = new VolvoV2();
line2: Volvo v = new VolvoV3();

Bilang karagdagan sa mga interface, ito ay nagkakahalaga ng pagpapatuloy tungkol sa mga Abstract na Klase at Klase. Baka mamaya, kapag may ilang oras pa akong libre. ))) PS: Guys, humihingi ako ng lahat ng pintas sa ilalim ng post o sa PM, lubos kong naiintindihan na lahat ay mayroon nito))) at palaging interesado akong marinig ito, dahil ito ay isang dahilan upang maging mas mahusay at muli magpatuloy sa pagsulong. With that, maraming salamat sa inyong lahat at good luck sa programming. )))