Ipinapatupad sa Java

Kapag pinag-uusapan ng ilan ang Java OOP paradigm of inheritance, karaniwang ibig sabihin nila ay pagpapalawak ng parent class na may inheritor, isang child class. Gayunpaman kapag nakita mo ang Java na nagpapatupad ng keyword, nangangahulugan ito na lumipat kami sa isa pang antas ng abstraction at magsimulang magtrabaho kasama ang Mga Interface sa Java. Pag-uusapan natin kung ano ang mga interface, para saan ang mga ito, kung paano nangyayari ang pagpapatupad.

Ano ang interface at pagpapatupad

Marahil ay narinig mo na ang salitang "interface" nang maraming beses. Halimbawa, ang isang computer ay may input interface (mouse at keyboard), maraming mga program ang may mga user interface. Sa pinakamalawak na kahulugan, ang isang interface ay isang link sa pagitan ng dalawang nakikipag-ugnayan na partido. Halimbawa, ang parehong keyboard o remote control ng TV. Sa programming, at partikular sa Java, ang isang interface ay isang partikular na kontrata na nagsasabi kung ano ang gagawin ng klase na nagpapatupad nito. Ang isang interface ay tumutukoy lamang sa pag-uugali. Wala itong sinasabi tungkol sa bagay na magpapatupad nito. Maaari kang magdeklara ng isang interface sa Java tulad nito:

public interface MyInterface  {

     // constants declaration 
     // methods without implementation
     // static methods
     // default methods (default)
     // private methods
}

Narito ang isang syntax ng Implements sa Java:

public class MyClass implements MyInterface{
//implementing the methods of MyInterface 
//Other code
} 

Inilalarawan ng isang interface ang pag-uugali nang hindi ito tinukoy. Halimbawa, ang isang pag-uugali tulad ng "paggalaw" ay maaaring ilapat sa iba't ibang uri ng mga bagay: isang bisikleta, isang tao, isang kotse, tubig sa isang ilog, at iba pa. Ang pag-uugali ng paglangoy ay maaaring pag-uugali ng isang pato, isang barko, o isang isda. Ang mga bagay na ito ay walang pagkakatulad maliban sa maaari silang gumalaw o lumangoy. Oo, at ang mismong paggalaw sa paglangoy ay ibang-iba sila. Gayunpaman, sa Java maaari kang lumikha ng mga klase ng Duck , Boat , Fish at hayaan silang ipatupad ang kakayahang lumangoy. Dito ginagamit ang keyword na Java Implements .

Ipatupad ang Halimbawa ng keyword

public interface Swimmable {
  
   void moveForward();
   void TurnRight();
   void TurnLeft();
  
}

Tulad ng nakikita mo, ang mga pamamaraan mismo ay hindi ipinatupad. Ngunit ipinahayag namin na ang mga klase na nagpapatupad ng interface na ito ay dapat na marunong lumangoy sa isang tuwid na linya, pati na rin lumiko sa kanan at kaliwa. Gumawa tayo ng mga klase na magpapatupad ng interface na ito.

public class Duck implements Swimmable {
//implementing the methods
   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

}

public class Fish implements Swimmable {

   public void moveForward() {
       System.out.println("I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft() {
       System.out.println("I am turning left...");
   }

   public void turnUp(){
       System.out.println("I am turning up...");
   }

   public void turnDown(){
       System.out.println("I am turning down...");
   }

   public void Stop() {
       System.out.println("I am relaxing somewhere under the water surface...");
   }
}

Ang lahat ng mga klase na nagpapatupad ng Swimmable interface, ayon sa kontrata, ay dapat na marunong lumangoy pasulong (ipatupad ang moveForward() na paraan), pati na rin lumiko sa kanan at kaliwa. Ang pagpapatupad ng mga pamamaraang ito ay kinakailangan. Magkaiba ang paglangoy ng isang pato at isda. Sabihin nating may dalawang karagdagang pamamaraan ang isda na nagpapatupad ng kakayahang lumangoy pataas at pababa. Walang ganito ang Swimmable interface. Gayunpaman, kung lumikha tayo ng isang bata ng klase ng Isda, halimbawa, Tuna o Salmon, sila, tulad ng bawat "Isda", ay magagawang lumangoy pataas at pababa.

Maramihang Mga Interface sa Java

Tulad ng malamang na alam mo na, hindi sinusuportahan ng Java ang maramihang pamana. Nangangahulugan iyon na ang isang klase ay maaaring mamana mula sa isang superclass lamang. Gayunpaman sa isang paraan maaari mo pa ring gamitin ang "maraming mana" sa Java, dahil ang isang klase ay maaaring magpatupad ng maraming interface.

To implement multiple interfaces, use the next syntax: 
interface MyFirstInterface {
   public void myMethod();
}
interface MySecondInterface {
   public void myOtherMethod();
}

// MyClass implements both MyFirstInterface and MySecondInterface
class MyClass implements MyFirstInterface, MySecondInterface {
   public void myMethod() {
      //method implementation
   }
   public void myOtherMethod() {
     //method implementation
   }
}

Halimbawa ng Maramihang Mga Interface

Tandaan na ang isang pato ay hindi lamang maaaring lumangoy, ngunit lumipad din. Isulat natin ang interface ng flight at ipatupad ito sa ating pato.

public interface Flyable {
   double startAge = 0.1;
   void fly();
}

public class Duck implements Swimmable, Flyable {

   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

   public void fly(){
       System.out.println("I am flying!!!");
   }

}

At muli, mahalagang tandaan kung bakit namin isinusulat ang interface. Sabihin natin kung ito ay ipinatupad ng isang ibon, isang eroplano, isang skydiver at isang dandelion, ang kanilang mga flight ay ganap na naiiba.