Pagpapamana ng maramihang mga interface

"Kumusta, Amigo! Sa wakas ay nakarating na kami sa isang bagay na tunay na kawili-wili. Ngayon sasabihin ko sa iyo ang tungkol sa maramihang pamana . Ang maramihang pamana ay talagang isang napakakaakit-akit at makapangyarihang tool. At kung hindi dahil sa maraming problema, kung gayon ang Java susuportahan ang maramihang pagmamana ng mga klase. Ngunit hindi, kaya dapat tayong maging kontento sa maramihang pagmamana ng mga interface . Na medyo kahanga-hanga rin."

Isipin na nagsusulat ka ng isang laro sa computer. At ang mga karakter nito (iyong mga bagay) ay dapat kumilos sa napakakomplikadong paraan: maglakad-lakad sa mapa, mangolekta ng mga item, magsagawa ng mga pakikipagsapalaran, makipag-usap sa ibang mga character, pumatay ng tao, magligtas ng iba. Sabihin nating nagawa mong hatiin ang lahat ng mga bagay sa 20 kategorya. Nangangahulugan ito na, kung ikaw ay mapalad, magagawa mong makayanan ang 20 klase lamang upang tukuyin ang iyong mga bagay. Ngunit narito ang catch: gaano karaming mga natatanging paraan ng pakikipag-ugnayan ang magkakaroon ng mga bagay na ito? Ang bawat uri ng bagay ay maaaring magkaroon ng natatanging pakikipag-ugnayan sa 20 iba pang uri ng mga bagay (nagbibilang din kami ng mga pakikipag-ugnayan sa mga bagay na may parehong uri). Sa madaling salita, kakailanganin mong magsulat ng code para sa 20 x 20 = 400 na pakikipag-ugnayan! At kung ang bilang ng mga natatanging uri ng bagay ay hindi 20, ngunit 100, kung gayon ang bilang ng mga pakikipag-ugnayan ay maaaring 10,000!

"Whoa! Ngayon naiintindihan ko na kung bakit napakahirap na gawain ang programming."

"Simple lang. Salamat sa maraming abstraction. At walang maliit na pasasalamat sa maraming inheritance ng mga interface."

Madalas nating pasimplehin ang pakikipag-ugnayan ng bagay kung ang mga tungkulin at/o kakayahan ay nakikipag-ugnayan sa halip na ang mga bagay mismo. At gaya ng alam na natin, ang mga kakayahan ay madaling maidagdag sa isang klase kapag nagpatupad ito ng ilang interface.

Kapag nagsusulat ng isang malaking programa, karaniwang ginagawa ito ng mga developer mula sa simula:

1) Tukuyin ang lahat ng kakayahan/gampanan.

2) Tukuyin ang interaksyon sa pagitan ng mga tungkuling ito.

3) Pagkatapos ay magtalaga lamang ng mga tungkulin sa lahat ng mga klase.

"Baka isang halimbawa?"

"Siyempre. Tingnan natin ang mga papel sa cartoon «Tom and Jerry».

interface Moveable
{}

interface Eatable
{}

interface Eat
{}

class Tom extends Cat implements Moveable, Eatable, Eat
{}

class Jerry extends Mouse implements Moveable, Eatable
{}

class Killer extends Dog implements Moveable, Eat
{}

Alam lamang ang tatlong tungkuling ito (mga interface), maaari kang magsulat ng isang programa at ilarawan ang tamang pakikipag-ugnayan sa pagitan ng mga tungkuling ito. Halimbawa, hahabulin ng isang bagay (sa pamamagitan ng Moveable interface) pagkatapos ng «isang makakain mo» at tatakas mula sa «isang makakain sa iyo». At lahat ng ito nang hindi nalalaman ang tungkol sa mga partikular na bagay. Kung magdaragdag ka ng higit pang mga bagay (mga klase) sa programa at panatilihin ang mga tungkuling ito, gagana pa rin ito nang maganda, na kinokontrol ang pag-uugali ng iyong mga bagay.