Mga interface sa Java

Kamusta! Ngayon ay pag-uusapan natin ang isang mahalagang konsepto sa Java - mga interface. Ang salita ay malamang na pamilyar sa iyo. Halimbawa, karamihan sa mga computer program at laro ay may mga interface. Sa isang malawak na kahulugan, ang isang interface ay isang uri ng "remote control" na nag-uugnay sa dalawang partido na nakikipag-ugnayan sa isa't isa. Ang isang simpleng halimbawa ng isang interface mula sa pang-araw-araw na buhay ay isang TV remote control. Nag-uugnay ito ng dalawang bagay, isang tao at isang TV, at nagsasagawa ng iba't ibang mga gawain: taasan o babaan ang volume, baguhin ang mga channel, i-on o i-off ang TV. Kailangang ma-access ng isang bahagi (ang tao) ang interface (pindutin ang remote control button) para sa kabilang panig upang maisagawa ang pagkilos. Halimbawa, para ilipat ng TV ang channel sa susunod. Sa kasong ito, hindi kailangang malaman ng user ang device ng TV at kung paano ipinapatupad sa loob nito ang proseso ng pagpapalit ng channel. Ang lahat ng user ay may access sa ay ang interface . Ang pangunahing gawain ay upang makuha ang ninanais na resulta. Ano ang kinalaman nito sa programming at Java? Direkta :) Ang paggawa ng interface ay halos kapareho ng paggawa ng isang regular na klase, ngunit sa halip na salita ay classtinukoy namin ang salita interface. Tingnan natin ang pinakasimpleng interface ng Java at alamin kung paano ito gumagana at kung ano ang kailangan nito:

public interface Swimmable  {

     public void swim();
}

Gumawa kami ng interface Swimmablena marunong lumangoy . Ito ay katulad ng aming remote control, na may isang "button": ang pamamaraan swim() ay "swim". Paano natin magagamit itong " remote control "? Para sa layuning ito ang pamamaraan, i.e. button sa aming remote control ay kailangang ipatupad. Upang gumamit ng isang interface, ang mga pamamaraan nito ay dapat ipatupad ng ilang mga klase ng aming programa. Bumuo tayo ng isang klase na ang mga bagay ay akma sa paglalarawang "maaaring lumangoy." Halimbawa, ang klase ng pato ay angkop Duck:

public class Duck implements Swimmable {

    public void swim() {
        System.out.println("Duck, swim!");
    }

    public static void main(String[] args) {

        Duck duck = new Duck();
        duck.swim();
    }
}

Ano ang nakikita natin dito? Ang isang klase Duckay nauugnay sa isang interface Swimmablegamit ang keyword implements. Kung naaalala mo, gumamit kami ng isang katulad na mekanismo upang ikonekta ang dalawang klase sa mana, tanging ang salitang " extends ". Ang " public class Duck implements Swimmable" ay maaaring isalin nang literal para sa kalinawan: "isang pampublikong klase Duckang nagpapatupad ng interface Swimmable." Nangangahulugan ito na ang isang klase na nauugnay sa isang interface ay dapat ipatupad ang lahat ng mga pamamaraan nito. Mangyaring tandaan: sa aming klase, Ducktulad ng sa interface , Swimmablemayroong isang pamamaraan swim(), at sa loob nito ay may ilang uri ng lohika. Ito ay isang ipinag-uutos na kinakailangan. Kung isinulat lang namin ang " public class Duck implements Swimmable" at hindi lumikha ng isang paraan swim()sa klase Duck, ang compiler ay magbibigay sa amin ng isang error: Duck ay hindi abstract at hindi override abstract pamamaraan swim() sa Swimmable Bakit ito nangyayari? Kung ipaliwanag namin ang error gamit ang halimbawa ng isang TV, lumalabas na binibigyan namin ang isang tao ng isang remote control na may pindutan na "baguhin ang channel" mula sa isang TV na hindi alam kung paano magpalit ng mga channel. Sa puntong ito, pindutin ang pindutan hangga't gusto mo, walang gagana. Ang remote control mismo ay hindi nagbabago ng mga channel: nagbibigay lamang ito ng isang senyas sa TV, sa loob kung saan ipinatupad ang isang kumplikadong proseso ng pagbabago ng channel. Ganoon din sa ating pato: dapat marunong itong lumangoy para ma-access ito gamit ang interface Swimmable. Kung hindi niya alam kung paano ito gagawin, Swimmablehindi ikokonekta ng interface ang dalawang panig - ang tao at ang programa. Ang isang tao ay hindi makakagamit ng isang paraan swim()upang gawing Ducklumutang ang isang bagay sa loob ng isang programa. Ngayon ay nakita mo nang mas malinaw kung para saan ang mga interface. Inilalarawan ng isang interface ang gawi na dapat mayroon ang mga klase na nagpapatupad ng interface na iyon. Ang "Gawi" ay isang koleksyon ng mga pamamaraan. Kung gusto naming lumikha ng maraming messenger, ang pinakamadaling paraan upang gawin ito ay sa pamamagitan ng paggawa ng interface Messenger. Ano ang dapat gawin ng sinumang messenger? Sa pinasimpleng anyo, tumanggap at magpadala ng mga mensahe.

public interface Messenger{

     public void sendMessage();

     public void getMessage();
}

At ngayon ay maaari na lang nating gawin ang ating mga messenger class sa pamamagitan ng pagpapatupad ng interface na ito. Ang compiler mismo ay "pipilitin" sa amin na ipatupad ang mga ito sa loob ng mga klase. Telegram:

public class Telegram implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a message to Telegram!");
    }

     public void getMessage() {
         System.out.println("Reading the message in Telegram!");
     }
}

WhatsApp:

public class WhatsApp implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a WhatsApp message!");
    }

     public void getMessage() {
         System.out.println("Reading a WhatsApp message!");
     }
}

Viber:

public class Viber implements Messenger {

    public void sendMessage() {

        System.out.println("Sending a message to Viber!");
    }

     public void getMessage() {
         System.out.println("Reading a message in Viber!");
     }
}

Anong mga benepisyo ang ibinibigay nito? Ang pinakamahalaga sa kanila ay maluwag na pagkabit. Isipin na kami ay nagdidisenyo ng isang programa kung saan kami ay mangongolekta ng data ng customer. Ang klase Clientay dapat may isang field na nagsasaad kung aling messenger ang ginagamit ng kliyente. Kung walang mga interface, magiging kakaiba ito:

public class Client {

    private WhatsApp whatsApp;
    private Telegram telegram;
    private Viber viber;
}

Gumawa kami ng tatlong field, ngunit madaling magkaroon ng isang messenger ang isang kliyente. Hindi lang natin alam kung alin. At upang hindi maiwan nang walang komunikasyon sa kliyente, kailangan mong "itulak" ang lahat ng posibleng mga pagpipilian sa klase. Lumalabas na isa o dalawa sa kanila ang palaging naroroon null, at hindi na sila kailangan para gumana ang programa. Sa halip, mas mabuting gamitin ang aming interface:

public class Client {

    private Messenger messenger;
}

Ito ay isang halimbawa ng "loose coupling"! Sa halip na tukuyin ang isang partikular na klase ng messenger sa klase Client, binabanggit lang namin na ang kliyente ay may messenger. Alin ang matutukoy sa panahon ng programa. Ngunit bakit kailangan natin ng mga interface para dito? Bakit sila idinagdag sa wika? Ang tanong ay mabuti at tama! Ang parehong resulta ay maaaring makamit gamit ang ordinaryong mana, tama? Ang klase Messengeray ang parent class, at Viber, Telegramat WhatsAppang mga tagapagmana. Sa katunayan, ito ay posible na gawin ito. Ngunit may isang catch. Tulad ng alam mo na, walang multiple inheritance sa Java. Ngunit mayroong maraming mga pagpapatupad ng mga interface. Ang isang klase ay maaaring magpatupad ng maraming mga interface hangga't gusto nito. Isipin na mayroon kaming isang klase Smartphonena may field Application- isang application na naka-install sa isang smartphone.

public class Smartphone {

    private Application application;
}

Ang aplikasyon at ang mensahero ay, siyempre, magkatulad, ngunit magkaiba pa rin sila. Ang Messenger ay maaaring parehong mobile at desktop, habang ang Application ay isang mobile application. Kaya, kung gumamit kami ng inheritance, hindi kami makakapagdagdag ng object Telegramsa class Smartphone. Pagkatapos ng lahat, ang isang klase Telegramay hindi maaaring magmana mula Applicationat mula sa Messenger! At nagawa na nating mamana ito mula sa Messenger, at idagdag ito sa klase sa form na ito Client. Ngunit ang isang klase Telegramay madaling ipatupad ang parehong mga interface! Samakatuwid, sa isang klase Clientmaaari naming ipatupad ang isang bagay Telegrambilang Messenger, at sa isang klase Smartphonebilang Application. Narito kung paano ito ginagawa:

public class Telegram implements Application, Messenger {

    //...methods
}

public class Client {

    private Messenger messenger;

    public Client() {
        this.messenger = new Telegram();
    }
}


public class Smartphone {

    private Application application;

    public Smartphone() {
        this.application = new Telegram();
    }
}

Ngayon ay magagamit na natin ang klase Telegramayon sa gusto natin. Sa isang lugar siya ay gaganap sa papel ng Application, sa isang lugar sa papel ng Messenger. Marahil ay napansin mo na na ang mga pamamaraan sa mga interface ay palaging "walang laman", ibig sabihin, wala silang pagpapatupad. Ang dahilan para dito ay simple: ang isang interface ay naglalarawan ng pag-uugali, hindi nagpapatupad nito. "Ang lahat ng mga bagay ng mga klase na nagpapatupad ng interface Swimmableay dapat na lumutang": iyon lang ang sinasabi sa amin ng interface. Kung paano eksaktong lumangoy ang isang isda, pato o kabayo ay may tanong para sa mga klase Fish, Duckat Horse, at hindi para sa interface. Tulad ng pagpapalit ng channel ay ang gawain ng isang TV. Ang remote ay nagbibigay lamang sa iyo ng isang pindutan upang gawin ito. Gayunpaman, ang Java8 ay may isang kawili-wiling karagdagan - mga default na pamamaraan. Halimbawa, ang iyong interface ay may 10 pamamaraan. 9 sa mga ito ay ipinatupad nang iba sa iba't ibang klase, ngunit ang isa ay pareho ang ipinatupad sa lahat. Noong nakaraan, bago ang paglabas ng Java8, ang mga pamamaraan sa loob ng mga interface ay walang pagpapatupad sa lahat: ang compiler ay agad na naghagis ng isang error. Ngayon ay maaari mo itong gawin tulad nito:

public interface Swimmable {

   public default void swim() {
       System.out.println("Swim!");
   }

   public void eat();

   public void run();
}

Gamit ang keyword default, gumawa kami ng paraan sa interface na may default na pagpapatupad. Kakailanganin nating ipatupad ang iba pang dalawang pamamaraan, eat()at run(), ang ating sarili sa lahat ng klase na magpapatupad ng Swimmable. Hindi na kailangang gawin ito sa pamamaraan swim(): ang pagpapatupad ay magiging pareho sa lahat ng mga klase. Sa pamamagitan ng paraan, nakatagpo ka ng mga interface nang higit sa isang beses sa mga nakaraang gawain, bagama't hindi mo ito napansin mismo :) Narito ang isang malinaw na halimbawa: Nakipagtulungan ka sa mga interface Listat Set! Mas tiyak, sa kanilang mga pagpapatupad - ArrayList, LinkedList, HashSetat iba pa. Ang parehong diagram ay nagpapakita ng isang halimbawa kapag ang isang klase ay nagpapatupad ng ilang mga interface nang sabay-sabay. Halimbawa, LinkedListipinapatupad nito ang mga interface Listat Deque(double-sided queue). Pamilyar ka rin sa interface Map, o sa halip, sa mga pagpapatupad nito - HashMap. Sa pamamagitan ng paraan, sa diagram na ito maaari mong makita ang isang tampok: ang mga interface ay maaaring minana mula sa bawat isa. Ang interface SortedMapay minana mula sa Map, at Dequeminana mula sa queue Queue. Ito ay kinakailangan kung gusto mong ipakita ang koneksyon sa pagitan ng mga interface, ngunit ang isang interface ay isang pinahabang bersyon ng isa pa. Tingnan natin ang isang halimbawa na may interface Queue- isang queue. Hindi pa namin napag-uusapan ang mga koleksyon Queue, ngunit medyo simple ang mga ito at nakaayos tulad ng isang regular na linya sa isang tindahan. Maaari kang magdagdag ng mga elemento lamang sa dulo ng pila, at alisin lamang ang mga ito mula sa simula. Sa isang tiyak na yugto, kailangan ng mga developer ng pinalawak na bersyon ng pila para maidagdag at matanggap ang mga elemento mula sa magkabilang panig. Ganito ginawa ang isang interface Deque- isang two-way queue. Naglalaman ito ng lahat ng mga pamamaraan ng isang regular na pila, dahil ito ang "magulang" ng isang two-way na pila, ngunit ang mga bagong pamamaraan ay idinagdag.