Interface sa Java

Tulad ng alam mo, ang lahat sa Java ay binubuo ng mga bagay, at ang mga bagay ay may estado (mga patlang) at pag-uugali (tinukoy ng mga pamamaraan). Ang pag-uugali ng isang klase ay kung ano ang maaaring magbigkis nito sa iba pang mga klase. Maaaring magkaroon ng iba't ibang katangian ang pag-uugali, at kung minsan ay mas maginhawang ilipat ito sa labas ng klase, lalo na pagdating sa pakikipag-ugnayan sa labas ng mundo. Tulad ng remote control ng TV ay nasa labas ng "kahon" mismo. Ang remote control ay isang interface para sa pakikipag-ugnayan ng user sa mga function ng TV. Halimbawa, maaari mong isipin ang isang klase na nagpapatupad ng abstract na eroplano o helicopter. Ang mga bagay ng parehong klase tulad ng karamihan sa mga ibon ay maaaring lumipad, at lahat sila ay gumagawa nito nang iba. Marahil ay sulit na ilipat ang feature na ito sa isang hiwalay na entity, at lahat ng potensyal na "flyer" ay mamanahin mula sa entity na ito? Kung pamilyar ka na sa mga abstract na klase, maaari ka lang gumawa ng abstract class na Flyable at "manahin" ang mga klase ng Copter at Plane mula dito. Gayunpaman, paano kung mayroong ilang mga naturang pag-aari? Halimbawa, ang mga eroplano at helicopter ay maaaring lumipad, ngunit naglalakbay din sa lupa. Kahit na gumawa kami ng klase ng Ride, hindi na namin maitalaga dito si Copter at Plane. Pagkatapos ng lahat, ang bawat klase ng Java ay mayroon lamang isang klase ng magulang. Ang paggamit ng mga interface sa wikang Java ay bahagyang nalulutas ang problemang ito. Tinutukoy ng mga interface sa Java ang ilang functionality na walang partikular na pagpapatupad, na pagkatapos ay ipinatupad ng mga klase na gumagamit ng mga interface na ito. At ang isang klase ay maaaring magpatupad ng maraming mga interface. Sa katunayan, sa pamamagitan ng pagpapatupad ng isang interface sa Java, ipinapahayag namin na may magagawa ang aming klase, iniuulat namin ang pag-uugali nito. Isinasagawa na namin ang konkretong pagpapatupad ng pag-uugali sa klase. Kaya. magkaiba ang pag-alis ng eroplano at helicopter: ang eroplano ay nangangailangan ng runway, habang ang isang helicopter ay karaniwang lumilipad nang patayo. Ang ganitong mga detalye ay pinakamahusay na ipinatupad sa loob ng klase.

Mga interface sa Java

Upang tukuyin ang isang interface sa wikang Java, ginagamit ang keyword ng interface. Halimbawa:

interface Voice {

    void talk();
}

Ang interface sa itaas ay tinatawag na Voice . Maaaring tukuyin ng isang interface sa Java ang mga constant at pamamaraan, na maaaring may mga pagpapatupad o wala. Karaniwan, ang mga pamamaraan ng interface ay walang pagpapatupad, tulad ng sa halimbawang ito. Ang mga pamamaraan sa mga interface na walang pagpapatupad ay tulad ng mga abstract na pamamaraan ng mga abstract na klase. Karaniwang walang access modifier ang mga paraan ng interface. Gayunpaman, ang pag-access ay aktwal na pampubliko bilang default dahil ang layunin ng isang interface ay upang tukuyin ang pag-andar para sa isang pagpapatupad ng klase. Samakatuwid, ang lahat ng pag-andar ay dapat na bukas para sa pagpapatupad. Upang ipatupad ang isang interface, gamitin ang Implements na keyword habang ipinapahayag ang iyong klase. Bukod dito, kung ang isang interface ay naglalaman ng isang pamamaraan na walang pagpapatupad, kung gayon ang pamamaraang iyon ay dapat ipatupad sa klase ng pagpapatupad.

public class Duck implements Voice {


@Override
public void voice() {
   System.out.println("Quack");
}


    }

Halimbawa ng interface ng code

Kumuha tayo ng mas kumpletong halimbawa. Bawat (well, halos lahat) hayop ay may kakayahang gumawa ng mga tunog. Gumawa tayo ng Java interface Voice para sa kasong ito. Mayroon itong talk() na pamamaraan na walang pagpapatupad.

public interface Voice {
   void talk();
}

Ngayon ang lahat ng mga klase na sumusuporta sa Voice interface ay dapat na mayroong pagpapatupad ng talk() na pamamaraan. Gumawa tayo ng dalawang klase — Pusa at Aso at ipahiwatig na ipinapatupad nila ang interface ng Voice . Sa kasong ito, kung hindi ka magpapatupad ng klase dito, hindi gagana ang program. Ang pagpapatupad ng mga pamamaraan ay napaka-simple. Kapag tinatawag ang talk() method ng isang object ng Cat class, ang text na katumbas ng meow ay ipapakita sa screen, sa kaso ng Dog class, isang bark. Magdaragdag din kami ng mga getter, setter at isang constructor sa mga klase.

public class Cat implements Voice {
   String name;
   String breed;
   int year;

   public Cat(String name, String breed, int year) {
       this.name = name;
       this.breed = breed;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getBreed() {
       return breed;
   }

   public void setBreed(String breed) {
       this.breed = breed;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("meow...");
   }
}

public class Dog implements Voice {
   String name;
   String color;
   int year;

   public Dog(String name, String color, int year) {
       this.name = name;
       this.color = color;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("WOF WOF");
   }
}

Sa katunayan, ang aming mga klase at pagpapatupad ng mga pamamaraan ay halos magkapareho. Gumawa tayo ng isa pang klase, Parrot , na may suporta sa Voice . Ang talk() method lang ang gagana sa ibang paraan: ang user ay maglalagay ng string sa console, at ang parrot ay "uulitin" ito gamit ang talk() method.

import java.util.Scanner;

public class Parrot implements Voice {
   String name;
   String color;
   int year;

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       Scanner scanner = new Scanner(System.in);
       System.out.println("WHat should I repeat after you?...");
       String s =  scanner.nextLine();
       System.out.println(s);
   }
}

Ngayon, lumikha tayo ng isang klase ng pagsubok at tingnan kung ano ang magiging resulta ng programa kung tatawagin natin ang talk() na paraan ng mga bagay ng Cat , Dog at Parrot classes.

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Parrot parrot = new Parrot();
       parrot.talk();
   }
}

Nasa ibaba ang output. Ang berdeng text ay ang isang user na naka-print sa console.

Mga Default na Paraan

Bago ang paglabas ng JDK 8 kapag nagpapatupad ng interface sa Java, kinailangan naming ipatupad ang lahat ng pamamaraan nito sa isang klase. Kasabay nito, ang Java interface mismo ay maaaring maglaman lamang ng mga kahulugan ng pamamaraan nang walang tiyak na pagpapatupad. Nagdaragdag ang JDK 8 ng bagong functionality — mga default na pamamaraan. Ngayon ang mga interface ng Java ay maaaring magkaroon ng hindi lamang mga kahulugan ng pamamaraan kundi pati na rin ang mga default na pagpapatupad. Ginagamit ang mga ito kung ang klase ay nagpapatupad ng interface ngunit hindi nagpapatupad ng pamamaraan. Halimbawa, baguhin natin ang paraan ng talk() sa interface ng Voice sa default na paraan. Magsusulat din kami ng bagong klase ng Duck na pinagana ng Voice na walang pagpapatupad ng paraan ng pag-uusap .

public interface Voice {
   default void talk() {
       System.out.println("I can talk...");
   }
}

public class Duck implements Voice {

   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!!!");
   }

}

Ngayon baguhin natin ng kaunti ang ating klase sa pagsusulit.

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Duck duck = new Duck();
       duck.talk();
   }
}

Ang output ay narito: Kita mo? Sa mga bagay ng klase ng Aso at Pusa , tinatawag ang overridden method talk() , ngunit sa isang object ng Duck class, ang default na paraan mula sa interface ay tinatawag. Kaya, ang default na paraan ay isang paraan lamang na walang mga modifier at minarkahan ng default na keyword. Hindi namin kailangang ipatupad ang default na paraan sa klase na nagpapatupad ng interface, ngunit maaari naming i-override ito.

Mga Static na Paraan

Dahil ang JDK 8 static na pamamaraan ay magagamit sa mga interface ng Java — ang mga ito ay katulad ng mga pamamaraan ng klase:

interface Voice {

    void talk();

    static void check(){

        System.out.println("checked...");
    }
}

Upang sumangguni sa isang static na paraan ng isang interface, tulad ng sa kaso ng mga klase, isulat ang pangalan ng interface at ang pamamaraan:

public static void main(String[] args) {

    Voice.check();
}

Maramihang Pagpapatupad ng Mga Interface

Kung kailangan nating maglapat ng ilang mga interface sa klase ng Java, lahat sila ay nakalista na may kuwit pagkatapos ng salitang ipinatupad :

public class Duck implements Swimmable, Flyable, Voice {

    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!!!");
    }

}