"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
"
Code | Beschrijving en feiten |
---|---|
|
1) In plaats van het woord class schrijven we interface .
2) Het bevat alleen abstracte methoden (het woord abstract hoeft niet te worden toegevoegd). 3) In feite zijn alle methoden op interfaces openbaar. |
|
Een interface kan alleen andere interfaces erven.
U kunt veel bovenliggende interfaces hebben. |
|
Een klasse kan meerdere interfaces erven (en slechts één klasse). Om deze erfenis aan te tonen, gebruiken we het trefwoord implements .
De Met andere woorden, |
"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.
GO TO FULL VERSION