Interfețe

Modulul 2: Java Core
Nivel , Lecţie
Disponibil

"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"

Cod Descriere și fapte
interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}
1) În loc de cuvânt class, scriem interface.

2) Conține doar metode abstracte (nu este nevoie să adăugați cuvântul abstract).

3) De fapt, toate metodele de pe interfețe sunt publice.

interface Element extends Drawable, HasValue
{
int getX();
int getY();
}
O interfață poate moșteni doar alte interfețe.

Puteți avea multe interfețe părinte.

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

}
O clasă poate moșteni mai multe interfețe (și o singură clasă). Pentru a arăta această moștenire, folosim cuvântul cheie  implements.

Clasa ChessItem a fost declarată abstractă: a implementat toate metodele moștenite, cu excepția draw.

Cu alte cuvinte, ChessItem conține o metodă abstractă:  draw().

"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:

Inainte de
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;
 }
După
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;
 }
}
Inainte de
public static void main(String[] args)
{
 Student student =
               new Student("Alibaba");
 System.out.println(student.getName());
}
După
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.

Comentarii
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION