Een beginnershandleiding voor het gebruik van interfaces in Java

Een interface is een referentietype dat wordt gebruikt om een ​​contract met een klasse af te dwingen. Een contract verwijst naar een verplichting om de methoden te implementeren die een interface definieert.

Interfaces bieden een abstractie tussen de methoden die ze definiëren en hoe de gebruiker ze in een klasse implementeert. Een praktisch gebruik hiervan is in API's (Application Programming Interfaces).

Met API's kan uw programma communiceren met andere programma's zonder te weten hoe ze worden geïmplementeerd. Dit is belangrijk om zowel bedrijfseigen redenen (voor het bedrijf dat de rechten bezit) als voor een gemakkelijke ontwikkeling van uw kant.

Laten we eens kijken hoe u Java-interfaces kunt gebruiken.

Interfaces definiëren

Om een ​​interface te declareren, plaatst u het trefwoord koppel voor de interfacenaam.

interface Auto{
// constante declaraties, indien aanwezig 
int banden = 4;
// methode handtekeningen 
int lichten (int helderheid);
int turn (int banden, String richting){
// een code
}
}

In de koptekst van uw interface kunt u ook het zichtbaarheidsniveau vóór het trefwoord opnemen koppel.

De waarden in een interface zijn constant. Deze waarden zijn standaard openbaar, statisch en laatste. Daarom is het niet nodig om deze trefwoorden te gebruiken bij het declareren van waarden in de hoofdtekst van een interface.

Verwant: Variabel bereik in Java beheren

De body van een interface kan ook hebben: standaard, abstract, statisch methoden. Deze methoden zijn standaard openbaar, dus het is niet nodig om deze toegangsmodifiers aan te geven wanneer u ze declareert.

Abstracte methoden worden gedeclareerd door de accolades van de hoofdtekst van een methode weg te laten. Zie regel 7 in de bovenstaande code. Statische methoden worden gedeclareerd door verder te gaan met de naam van de methode met het trefwoord statisch & standaardmethoden worden gedeclareerd met de standaard modificator.

Het zou nu een goed moment zijn om te vermelden dat je methoden moet gebruiken die in een interface zijn gedeclareerd in alle klassen die het implementeren. Als u dit niet doet, zal de compiler "het contract afdwingen" door een compilatiefout te geven.

Deze specifieke eigenschap van interfaces kan enkele nadelen hebben. Overweeg een geval waarin een aanbieder van een Application Programming Interface (API) besluit meer methoden aan hun interfaces toe te voegen, maar verschillende apps zijn gebaseerd op de oude interfaces. Ontwikkelaars die de oude interfaces in hun programma's gebruiken, zouden hun code moeten herschrijven, wat niet praktisch is.

Dus, dat is waar standaard methoden komen binnen. Ze stellen API-providers in staat om meer methoden aan hun interfaces toe te voegen en tegelijkertijd binaire compatibiliteit met oudere interfaceversies te garanderen.

standaard int getDirection (Stringcoördinaten){
// schrijf wat code om een ​​standaardimplementatie te geven 
}

De bovenstaande methode laat zien hoe een standaardmethode genaamd getDirection wordt verklaard. Merk op dat u een implementatie van een standaardmethode moet opnemen wanneer u deze schrijft.

Interfaces gebruiken

Nu we interfaces in Java hebben gedefinieerd, kunnen we verder gaan met hoe u ze kunt implementeren. U komt dit te weten in het onderstaande gedeelte.

Interfaces implementeren

Gebruik het trefwoord. om een ​​interface te implementeren implementeert met behulp van deze syntaxis:

klasse A implementeert interface P{
}

Onthoud dat je alle interfacemethoden in de klas moet gebruiken. U kunt deze regel alleen negeren als een van de methoden is gedefinieerd als standaard in de interface.

Verwant: Een inleiding tot het gebruik van gelinkte lijsten in Java

Als je wilt dat je klas meerdere interfaces implementeert, kun je ze scheiden met komma's in je headerdeclaratie.

Voorbeeld:

klasse A implementeert interface P, Q, R{
}

Als de klasse die de interface implementeert een subklasse is, gebruikt u de onderstaande syntaxis:

klasse A breidt B uit werktuigen C, D{
}

Interfaces maken meerdere overervingen in Java mogelijk. Gewoonlijk kan een klasse slechts één klasse uitbreiden (enkele overerving). Interfaces zijn de enige manier waarop Java meerdere overervingen kan uitvoeren.

Interfaces kunnen ook andere interfaces uitbreiden, net zoals een klasse een andere klasse kan uitbreiden. De onderliggende interface erft de methoden van de interface die het uitbreidt.

Zie het voorbeeld hieronder:

interface A breidt B uit{ 
}

Behalve het gebruik van standaardmethoden om een ​​interface te wijzigen zonder dat de ontwikkelaars hun huidige programma's hoeven aan te passen, kunt u ook de bestaande interfaces uitbreiden.

Nu heb je wat basiskennis over Java-interfaces

Interfaces in Java demonstreren abstractie, een van de vier pijlers van objectgeoriënteerd programmeren. Polymorfisme is een van die vier pijlers. Het verwijst naar het vermogen van een methode om vele vormen aan te nemen.

U kunt polymorfisme in Java implementeren door middel van overbelasting van de methode of overschrijven van methoden. Het volgende op uw Java-leeslijst zou moeten zijn hoe u deze functies implementeert.

Polymorfisme in Java: methoden overbelasten of negeren

Verminder de code die u schrijft met overbelasting en overschrijven van methoden.

Lees volgende

Over de auteur