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

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

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

Код Описание и факти
interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}
1) Вместо думата classпишем interface.

2) Съдържа само абстрактни методи (няма нужда да добавяте думата абстрактно).

3) Всъщност всички методи на интерфейсите са публични.

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

}
Един клас може да наследи няколко интерфейса (и само един клас). За да покажем това наследство, използваме ключовата дума  implements.

Класът ChessItem беше обявен за абстрактен: той имплементира всички наследени методи с изключение на draw.

С други думи, ChessItem съдържа един абстрактен метод:  draw().

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

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

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 предлага компромис:   не можете да наследявате множество класове, но можете да реализирате множество интерфейси. Един интерфейс може да има няколко родителски интерфейса.  Един клас може да реализира множество интерфейси и да наследи само един родителски клас.