Интерфейси

„Здравей, Амиго! Днес ще направиш някои открития. Темата за днес – дрънкане на барабани, моля – са интерфейсите. “

„Да. Толкова прекрасен ден, че се прибирам вкъщи да се изкъпя.“

" Интерфейсът е дете на абстракция и полиморфизъм. Интерфейсът много прorча на абстрактен клас, където всички методи са абстрактни. Той се декларира по същия начин като клас, но с ключовата дума. Ето няколко примера: interface"

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

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

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

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

"Интересно. Но защо имаме нужда от интерфейси? Кога се използват?"

„Интерфейсите имат две силни предимства пред класовете:“

1) Разделяне на "дефиниции на метод" от имплементации на метод.

По-рано ви казах, че ако искате да позволите на други класове да извикват методите на вашия клас, тогава трябва да ги маркирате катоpublic . Ако искате определени методи да се извикват само от вашия собствен клас, тогава те трябва да бъдат отбелязани с private. С други думи, ние разделяме методите на класа на две категории: «за всички» и «само за мен».

Можем да използваме интерфейси, за да укрепим още повече това разделение. Ще направим специален „клас за всеки“, който ще наследи втори „клас само за мен“. Това би изглеждало приблизително така:

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

Разделихме нашия клас на две части: интерфейс и клас, който имплементира интерфейса.

— И така, Howво е предимството?

"Същият интерфейс може да бъде имплементиран от (наследени) различни класове. И всеки клас може да има собствено поведение. Точно като ArrayList и LinkedList са две различни реализации на интерфейса List. "

По този начин ние крием не само различните имплементации, но и класовете, които съдържат имплементациите (можем просто да използваме интерфейси навсякъде в codeа). Това ни позволява много гъвкаво да заменяме някои обекти с други обекти, докато програмата работи, променяйки поведението на обекта без знанието на някой от класовете, които го използват.

В комбинация с полиморфизма това е много мощна техника. В момента далеч не е ясно защо трябва да правим това. Първо трябва да се сблъскате с програми, състоящи се от десетки or стотици класове, за да оцените How интерфейсите могат значително да опростят живота ви.

2) Множествено наследяване.

В Java всеки клас може да има само един родителски клас. В други езици за програмиране класовете често могат да имат няколко родителски класа. Това е много удобно, но създава и много проблеми.

Java предлага компромис:   не можете да наследявате множество класове, но можете да реализирате множество интерфейси. Един интерфейс може да има няколко родителски интерфейса.  Един клас може да реализира множество интерфейси и да наследи само един родителски клас.