"Hello, Amigo! Ako ito—muli. Gusto kong bigyan ka ng isa pang punto ng view sa mga interface. Nakikita mo, kadalasan ang isang klase ay isang modelo ng isang partikular na bagay. Sa kabilang banda, ang mga interface ay higit na katulad ng mga kakayahan ng isang bagay o mga tungkulin, sa halip na ang bagay mismo."

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 «Kaya kong gumalaw», «Kaya kong magdala ng mga tao», at «Kaya kong mag-park», ay mas mahusay na kinakatawan bilang mga interface. Tingnan ang halimbawang ito:

Java code Paglalarawan 
interface Moveable
{
void move(String newAddress);
}
 Naaayon sa kakayahang gumalaw. 
interface Driveable
{
void drive(Driver driver);
}
 Naaayon sa kakayahang gumalaw. 
interface Transport
{
void addStuff(Object stuff);
Object removeStuff();
}
 Naaayon sa kakayahang magdala ng kargamento. 
class Wheel implements Moveable
{
...
}
 Isang klase ng "gulong". May kakayahang gumalaw. 
class Car implements Moveable, Drivable, Transport
{
...
}
 Isang klase ng "kotse". May kakayahang gumalaw, mamaneho ng isang tao, at magdala ng kargamento. 
class Skateboard implements Moveable, Driveable
{
...
}
 Isang klase ng "skateboard". May kakayahang kumilos at kontrolin ng isang tao.
Java university

Ang mga interface ay lubos na nagpapasimple sa buhay ng programmer. Ang mga programa ay madalas na mayroong libu-libong mga bagay, daan-daang mga klase, at ilang dosenang mga interface (mga tungkulin) lamang. Mayroong ilang mga tungkulin, ngunit maaari silang pagsamahin sa maraming paraan (mga klase).

Ang buong punto ay hindi mo kailangang magsulat ng pakikipag-ugnayan sa pagtukoy ng code sa bawat ibang klase. Ang kailangan mo lang gawin ay makipag-ugnayan sa mga tungkulin (mga interface).

Isipin na ikaw ay isang robotic builder. Mayroon kang dose-dosenang mga subordinate na robot at bawat isa sa kanila ay maaaring magkaroon ng maraming kasanayan. Ipagpalagay na kailangan mong agarang tapusin ang pagbuo ng isang pader. Kukunin mo lang ang lahat ng mga robot na may kakayahang "magtayo" at sabihin sa kanila na itayo ang pader. Wala ka talagang pakialam kung aling mga robot ang gumagawa nito. Hayaan itong maging isang robotic watering can. Kung marunong itong bumuo, hayaan itong bumuo.

Narito ang magiging hitsura nito sa code:

Java code Paglalarawan 
static interface WallBuilder
{
void buildWall();
}
 Kakayahang "magtayo ng pader". Nauunawaan ang utos na «magtayo ng pader» (may naaangkop na pamamaraan). 
static class WorkerRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class GuardRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class WateringCan
{
…
}
 Mga robot na may ganitong kakayahan/kasanayan.

Ang pagtutubig ay hindi maaaring magtayo ng pader (hindi nito ipinapatupad ang interface ng WallBuilder).

 
public static void main(String[] args)
{
 //add all robots to a list
 ArrayList robots = new ArrayList();
 robots.add(new WorkerRobot());
 robots.add(new GuardRobot());
 robots.add(new WateringCan());

 //build a wall if you can
 for (Object robot: robots)
 {
  if (robot instanceof WallBuilder)
  {
   WallBuilder builder = (WallBuilder) robot;
   builder.buildWall();
   }
  }
 }
}
 Paano natin ibibigay ang utos na magtayo ng pader?

"Iyan ay kamangha-manghang kawili-wili. Hindi ko pinangarap na ang mga interface ay maaaring maging isang kawili-wiling paksa."

"At pagkatapos ang ilan! Kasama ng polymorphism, ito ay lubos na nakakagulat."