Ang kakanyahan ng mga interface

1. Kakayahan

Upang mas maunawaan ang mga benepisyo ng mga interface at kung saan gagamitin ang mga ito, kailangan nating pag-usapan ang ilang mas abstract na mga bagay.

Ang isang klase ay karaniwang nagmomodelo ng isang partikular na bagay. Ang isang interface ay hindi gaanong tumutugma sa mga bagay, at higit pa sa kanilang mga kakayahan o tungkulin.

Halimbawa, ang mga bagay tulad ng mga kotse, bisikleta, motorsiklo, at gulong ay pinakamahusay na kinakatawan bilang mga klase at bagay. Ngunit ang kanilang mga kakayahan — tulad ng "Maaari akong sakyan", "Kaya kong maghatid ng mga tao", "Kaya kong tumayo" - ay mas mahusay na ipinakita bilang mga interface. Narito ang ilang halimbawa:

interface CanMove
{
   void move(String newLocation);
}

interface Rideable
{
   void ride(Passenger passenger);
}

interface CanTransport
{
   void addStuff(Object stuff);
   Object removeStuff();
}

class Wheel implements CanMove
{
   ...
}

class Car implements CanMove, Rideable, CanTransport
{
   ...
}

class Skateboard implements CanMove, Rideable
{
   ...
}

2. Mga tungkulin

Ang mga interface ay lubos na nagpapasimple sa buhay ng isang programmer. Kadalasan, ang isang programa ay may libu-libong mga bagay, daan-daang mga klase, ngunit ilang dosenang interface lamang , ibig sabihin, mga tungkulin . Mayroong ilang mga tungkulin, ngunit maraming mga paraan upang pagsamahin ang mga ito (mga klase).

Ang buong punto ay hindi mo kailangang magsulat ng code para sa bawat klase upang makipag-ugnayan sa bawat iba pang klase. Kailangan mo lang makipag-ugnayan sa kanilang mga tungkulin (mga interface).

Isipin na ikaw ay isang tagapagsanay ng alagang hayop. Ang bawat isa sa mga alagang hayop na katrabaho mo ay maaaring magkaroon ng iba't ibang kakayahan. Nakipagtalo ka sa iyong kapitbahay tungkol sa kung kaninong mga alagang hayop ang maaaring gumawa ng pinakamaraming ingay. Para maayos ang usapin, ihanay mo lang ang lahat ng mga alagang hayop na maaaring "magsalita", at bibigyan mo sila ng utos: Magsalita!

Wala kang pakialam kung anong klaseng hayop sila o kung ano pang kakayahan nila. Kahit na kaya nilang gumawa ng triple back somersault. Sa partikular na sandali na ito, interesado ka lamang sa kanilang kakayahang magsalita nang malakas. Narito kung ano ang magiging hitsura nito sa code:

interface CanSpeak
{
   void speak();
}

class Cat implements CanSpeak
{
   void speak()
   {
      println("MEOW");
   }
}

class Dog implements CanSpeak
{
   void speak()
   {
      println("WOOF");
   }
}

class Fish
{
   ...
}

public static void main(String[] args)
{
   // Add all the animals to the list
   ArrayList pets = new ArrayList();
   pets.add(new Cat());
   pets.add(new Dog());
   pets.add(new Fish());

   // If the ability exists, then make a sound
   for(Object pet: pets)
   {
      if (pet instanceof CanSpeak)
      {
         CanSpeak loudmouth = (CanSpeak) pet;
         loudmouth.speak();
      }
   }
}

Kapag ang bilang ng mga klase sa iyong mga programa ay umabot sa libu-libo, hindi ka mabubuhay nang walang mga interface. Sa halip na ilarawan ang pakikipag-ugnayan ng libu-libong klase, sapat na upang ilarawan ang pakikipag-ugnayan ng ilang dosenang mga interface — lubos nitong pinapasimple ang buhay.

At kapag pinagsama sa polymorphism, ang diskarteng ito sa pangkalahatan ay isang napakalaking tagumpay.

3. Ang defaultpagpapatupad ng mga pamamaraan ng interface

Ang mga abstract na klase ay maaaring magkaroon ng mga variable at pagpapatupad ng mga pamamaraan, ngunit hindi sila maaaring magkaroon ng maramihang mana. Ang mga interface ay hindi maaaring magkaroon ng mga variable o pagpapatupad ng mga pamamaraan, ngunit iyon ay maaaring magkaroon ng maramihang mana.

Ang sitwasyon ay ipinahayag sa sumusunod na talahanayan:

Kaya, gusto ng ilang programmer na magkaroon ng kakayahan ang mga interface na magkaroon ng mga pagpapatupad ng pamamaraan. Ngunit ang pagkakaroon ng kakayahang magdagdag ng pagpapatupad ng pamamaraan ay hindi nangangahulugan na ang isa ay palaging idaragdag. Idagdag ito kung gusto mo. O kung ayaw mo, edi huwag.

Bilang karagdagan, ang mga problema sa maramihang pamana ay pangunahing sanhi ng mga variable. Sa anumang kaso, iyon ang kanilang napagpasyahan at ginawa. Simula sa JDK 8, ipinakilala ng Java ang kakayahang magdagdag ng mga pagpapatupad ng pamamaraan sa mga interface.

Narito ang isang na-update na talahanayan (para sa JDK 8 at mas mataas):

Ngayon para sa mga abstract na klase pati na rin ang mga interface, maaari kang magdeklara ng mga pamamaraan na mayroon o walang pagpapatupad. At ito ay magandang balita!

Sa mga abstract na klase, ang mga pamamaraan na walang pagpapatupad ay dapat na unahan ng abstractkeyword. Hindi mo kailangang magdagdag ng kahit ano bago ang mga pamamaraan na may pagpapatupad. Sa mga interface, ang kabaligtaran ay totoo. Kung ang isang pamamaraan ay walang pagpapatupad, walang dapat idagdag. Ngunit kung mayroong pagpapatupad, defaultdapat na idagdag ang keyword.

Para sa pagiging simple, ipinakita namin ang impormasyong ito sa sumusunod na maliit na talahanayan:

Problema

Ang paggamit ng mga interface na may mga pamamaraan ay maaaring lubos na gawing simple ang malalaking hierarchies ng klase. Halimbawa, ang abstract InputStreamat OutputStreammga klase ay maaaring ideklara bilang mga interface! Nagbibigay-daan ito sa amin na gamitin ang mga ito nang mas madalas at mas maginhawa.

Ngunit mayroon nang sampu-sampung milyon (bilyon?) ng mga klase ng Java sa mundo. At kung sisimulan mong baguhin ang mga karaniwang aklatan, maaari kang masira ang isang bagay. Tulad ng lahat! 😛

Upang hindi aksidenteng masira ang mga kasalukuyang programa at aklatan, napagpasyahan na ang mga pagpapatupad ng pamamaraan sa mga interface ay magkakaroon ng pinakamababang inheritance precedence .

Halimbawa, kung ang isang interface ay nagmamana ng isa pang interface na may isang pamamaraan, at ang unang interface ay nagpahayag ng parehong paraan ngunit walang pagpapatupad, kung gayon ang pagpapatupad ng pamamaraan mula sa minanang interface ay hindi makakarating sa namamana na interface. Halimbawa:

interface Pet
{
   default void meow()
   {
      System.out.println("Meow");
   }
}

interface Cat extends Pet
{
   void meow(); // Here we override the default implementation by omitting an implementation
}

class Tom implements Cat
{
}

Ang code ay hindi mag-compile dahil ang Tomklase ay hindi nagpapatupad ng meow()pamamaraan.