Interfețe

"Bună, Amigo! Astăzi vei face câteva descoperiri. Subiectul de azi — sunetul de tobe, te rog — este interfețele. "

"Da. O zi atât de minunată încât mă întorc acasă să fac o baie."

" O interfață este copilul abstracției și polimorfismului. Interfața seamănă foarte mult cu o clasă abstractă în care toate metodele sunt abstracte. Este declarată la fel ca o clasă, dar cu cuvântul cheie . Iată câteva exemple: 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;
}

}

"Interesant. Dar de ce avem nevoie de interfețe? Când sunt folosite?"

„Interfețele au două avantaje puternice față de clase:”

1) Separarea „definițiilor metodei” de implementările metodei.

V-am spus anterior că, dacă doriți să permiteți altor clase să apeleze metodele clasei dvs., atunci trebuie să le marcați capublic . Dacă doriți ca anumite metode să fie apelate numai din propria clasă, atunci acestea trebuie marcate private. Cu alte cuvinte, împărțim metodele clasei în două categorii: „pentru toată lumea” și „doar pentru mine”.

Putem folosi interfețele pentru a întări și mai mult această separare. Vom face o „clasă specială pentru toată lumea” care va moșteni o a doua „clasă doar pentru mine”. Asta ar arata cam asa:

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());
}

Ne împărțim clasa în două părți: o interfață și o clasă care implementează interfața.

— Deci, care este avantajul?

"Aceeași interfață poate fi implementată de (moștenește) clase diferite. Și fiecare clasă poate avea propriul comportament. La fel ca ArrayList și LinkedList sunt două implementări diferite ale interfeței List. "

Astfel, ascundem nu numai diferitele implementări, ci și clasele care conțin implementările (putem folosi doar interfețe peste tot în cod). Acest lucru ne permite să înlocuim foarte flexibil unele obiecte cu alte obiecte în timp ce programul rulează, schimbând comportamentul unui obiect fără știrea vreuneia dintre clasele care îl folosesc.

În combinație cu polimorfismul, aceasta este o tehnică foarte puternică. În acest moment, nu este departe de a fi evident de ce ar trebui să facem asta. Mai întâi trebuie să întâlniți programe care constau din zeci sau sute de clase pentru a aprecia modul în care interfețele vă pot simplifica foarte mult viața.

2) Moștenirea multiplă.

În Java, fiecare clasă poate avea o singură clasă părinte. În alte limbaje de programare, clasele pot avea adesea mai multe clase părinte. Acest lucru este foarte convenabil, dar creează și o mulțime de probleme.

Java oferă un compromis:   nu poți moșteni mai multe clase, dar poți implementa mai multe interfețe. O interfață poate avea mai multe interfețe părinte.  O clasă poate implementa mai multe interfețe și poate moșteni o singură clasă părinte.