Interfaces in Java

Over het algemeen als we op een bepaalde manier werken object georiënteerd We hebben de vrijheid om veel klassen te modelleren waarmee we veel dingen uit de echte wereld naar digitaal formaat kunnen brengen, maar er zijn momenten waarop we deze klassen een aantal basisgedragingen nodig hebben die ons in staat stellen acties uit te voeren onder een groep van hen of gewoon in hun gedrag omvat iets in het bijzonder.
InterfacesOm dit te bereiken hebben we de interfaces, die erg lijken op de klassen waarin we methoden en constanten kunnen definiëren die zullen worden gebruikt door de klassen die ze implementeren, dit wordt gedaan om gedragingen toe te voegen die de klassen compatibel maken, om dingen te bereiken die net zo belangrijk zijn als vergelijking van objecten.
EEN koppel gedraagt ​​zich vergelijkbaar met een klasse, in feite Java Het behandelt het als volgt door een bestand te genereren van: Bytecode gescheiden door elk, bovendien, vergelijkbaar met een abstracte klasse, de Interfaces Ze kunnen niet worden geïnstantieerd, dit laat ons dan een optie over om ze te moeten implementeren via andere klassen die hun herdefiniëren abstracte methoden.
Om een ​​interface te maken, moeten we de volgende structuur volgen:

 interface-modifier InterfaceName {/ ** Constante declaraties Abstracte methodedeclaraties * /} 

We zien dan dat we moeten beginnen met het aangeven van de modifier, dit kan zijn: openbaar, beschermd, privé, dan gaan we verder met het interface-trefwoord, op deze manier Java Je kunt weten dat het geen klasse is en uiteindelijk de naam ervan, al binnenin kunnen we de constanten en abstracte methoden definiëren. Laten we in de volgende afbeelding een code zien van een reeds gedefinieerde interface.

We hebben dan een gemaakt openbare interface die eetbaar wordt genoemd en ons in staat stelt gedrag aan onze klassen toe te voegen door een abstracte methode te definiëren formulierEet (), We kunnen dan de manier definiëren waarop de objecten van de klassen die deze interface implementeren kunnen worden gegeten.
We hebben het woord implementeren meerdere keren genoemd als we het hebben over het maken van een interface in een klas, dit komt omdat het gereserveerde woord waarmee we de koppel met de klas is implementeert daarom definiëren we dit concept op deze manier.
In het volgende voorbeeld gaan we een implementatie zien van de interface die we in het vorige voorbeeld hebben gemaakt:

We zien dat we een klasse hebben gemaakt met de naam Kip dat erft van a abstracte klasse Dier en dat geeft ook invulling aan onze koppel Eetbaar, worden we hierdoor gedwongen om de abstracte methode ervan te herschrijven, zodat onze klasse kan werken.
Andere appEr is ook de mogelijkheid om een ​​interface te implementeren in een abstracte klasse zodat alle onderliggende klassen de abstracte methoden moeten erven en dus hun gedrag moeten modelleren zonder in elk van hen een implementatie te hoeven maken.
Hiermee beëindigen we deze tutorial, omdat we zien dat de interfaces een andere bron zijn die ons zal helpen om meer diepte te geven aan de concepten die we kunnen opnemen in onze applicaties gemaakt in Java.Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een ​​positief punt te geven