Interfaces

"Hallo, Amigo! Vandaag ga je wat ontdekkingen doen. Het onderwerp voor vandaag - tromgeroffel, alsjeblieft - is interfaces. "

'Ja. Een dag zo heerlijk dat ik naar huis ga om een ​​bad te nemen.'

" Een interface is het kind van abstractie en polymorfisme. De interface lijkt veel op een abstracte klasse waarin alle methoden abstract zijn. Het wordt op dezelfde manier gedeclareerd als een klasse, maar met het trefwoord . Hier zijn enkele voorbeelden: 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;
}

}

"Interessant. Maar waarom hebben we interfaces nodig? Wanneer worden ze gebruikt?"

"Interfaces hebben twee sterke voordelen ten opzichte van klassen:"

1) Scheiding van "methodedefinities" van methode-implementaties.

Ik heb je eerder verteld dat als je andere klassen wilt toestaan ​​om de methoden van jouw klasse aan te roepen, je ze moet markeren alspublic . Als u wilt dat bepaalde methoden alleen vanuit uw eigen klasse worden aangeroepen, moeten ze worden gemarkeerd met private. Met andere woorden, we verdelen de methoden van de klas in twee categorieën: «voor iedereen» en «alleen voor mij».

We kunnen interfaces gebruiken om deze scheiding nog meer te versterken. We zullen een speciale "klas voor iedereen" maken die een tweede "alleen-voor-mij-klas" zal erven. Dat zou er ongeveer zo uitzien:

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

We hebben onze klasse in twee delen gesplitst: een interface en een klasse die de interface implementeert.

"Dus wat is het voordeel?"

"Dezelfde interface kan worden geïmplementeerd door verschillende klassen (erven). En elke klasse kan zijn eigen gedrag hebben. Net zoals ArrayList en LinkedList twee verschillende implementaties zijn van de List-interface. "

We verbergen dus niet alleen de verschillende implementaties, maar ook de klassen die de implementaties bevatten (we kunnen gewoon overal in de code interfaces gebruiken). Hierdoor kunnen we heel flexibel sommige objecten vervangen door andere objecten terwijl het programma draait, waardoor het gedrag van een object verandert zonder medeweten van een van de klassen die het gebruiken.

In combinatie met polymorfisme is dit een zeer krachtige techniek. Op dit moment is het verre van duidelijk waarom we dit zouden moeten doen. U moet eerst programma's tegenkomen die uit tientallen of honderden klassen bestaan ​​om te begrijpen hoe interfaces uw leven enorm kunnen vereenvoudigen.

2) Meervoudige overerving.

In Java kan elke klasse slechts één bovenliggende klasse hebben. In andere programmeertalen kunnen klassen vaak meerdere bovenliggende klassen hebben. Dit is erg handig, maar het zorgt ook voor veel problemen.

Java biedt een compromis:   u kunt niet meerdere klassen erven, maar u kunt wel meerdere interfaces implementeren. Een interface kan meerdere bovenliggende interfaces hebben.  Een klasse kan meerdere interfaces implementeren en slechts één bovenliggende klasse erven.