Mga interface

"Hello, Amigo! Ngayon ay makakagawa ka ng ilang mga pagtuklas. Ang paksa para sa araw na ito—drum roll, please—ay mga interface. "

"Yep. A day so wonderful that I'm heading home to take a bath."

" Ang isang interface ay ang anak ng Abstraction at Polymorphism. Ang interface ay katulad ng isang abstract na klase kung saan ang lahat ng mga pamamaraan ay abstract. Ito ay idineklara sa parehong paraan bilang isang klase, ngunit kasama ang keyword . Narito ang ilang mga halimbawa: interface"

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"Interesting. Pero bakit kailangan natin ng mga interface? Kailan ginagamit ang mga ito?"

"Ang mga interface ay may dalawang malakas na pakinabang sa mga klase:"

1) Paghihiwalay ng "mga kahulugan ng pamamaraan" mula sa mga pagpapatupad ng pamamaraan.

Sinabi ko sa iyo dati na kung gusto mong payagan ang ibang mga klase na tawagan ang mga pamamaraan ng iyong klase, kailangan mong markahan ang mga ito bilangpublic . Kung gusto mong tawagin ang ilang partikular na pamamaraan mula sa sarili mong klase, dapat na markahan ang mga ito private. Sa madaling salita, hinahati namin ang mga pamamaraan ng klase sa dalawang kategorya: «para sa lahat» at «para sa akin lang».

Maaari kaming gumamit ng mga interface upang mas palakasin ang paghihiwalay na ito. Gagawa tayo ng isang espesyal na "klase para sa lahat" na magmamana ng pangalawang "para sa akin na klase". Iyon ay magmumukhang ganito:

class Student
{
 private String name;

 public Student(String name)
 {
  this.name = name;
 }

 public String getName()
 {
  return this.name;
 }

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

interface Student
{
 public String getName();
}

class StudentImpl implements Student
{
 private String name;
 public StudentImpl(String name)
 {
  this.name = name;
 }
 public String getName()
 {
  return this.name;
 }
 private void setName(String name)
 {
  this.name = name;
 }
}

public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}

public static void main(String[] args)
{
 Student student =
               new StudentImpl("Ali");
 System.out.println(student.getName());
}

Hinati namin ang aming klase sa dalawang bahagi: isang interface at isang klase na nagpapatupad ng interface.

"So ano ang advantage?"

"Ang parehong interface ay maaaring ipatupad ng (magmana) ng iba't ibang klase. At ang bawat klase ay maaaring magkaroon ng sarili nitong pag-uugali. Tulad ng ArrayList at LinkedList ay dalawang magkaibang pagpapatupad ng List interface. "

Kaya, itinatago namin hindi lamang ang iba't ibang mga pagpapatupad, kundi pati na rin ang mga klase na naglalaman ng mga pagpapatupad (maaari lang kaming gumamit ng mga interface saanman sa code). Nagbibigay-daan ito sa amin na napaka-flexible na palitan ang ilang mga bagay ng iba pang mga bagay habang tumatakbo ang programa, binabago ang pag-uugali ng isang bagay nang hindi nalalaman ng alinman sa mga klase na gumagamit nito.

Sa kumbinasyon ng polymorphism, ito ay isang napakalakas na pamamaraan. Sa ngayon, malayong malinaw kung bakit kailangan nating gawin ito. Kailangan mo munang makatagpo ng mga programa na binubuo ng dose-dosenang o daan-daang mga klase upang pahalagahan kung paano lubos na mapasimple ng mga interface ang iyong buhay.

2) Maramihang mana.

Sa Java, ang bawat klase ay maaari lamang magkaroon ng isang parent class. Sa ibang mga programming language, ang mga klase ay kadalasang maaaring magkaroon ng ilang parent class. Ito ay napaka-maginhawa, ngunit lumilikha din ito ng maraming problema.

Nag-aalok ang Java ng kompromiso:   hindi ka maaaring magmana ng maraming klase, ngunit maaari kang magpatupad ng maraming interface. Maaaring magkaroon ng ilang interface ng magulang ang isang interface.  Ang isang klase ay maaaring magpatupad ng maraming interface at magmana lamang ng isang parent class.