Inhoudsopgave
Dit is het derde deel van een reeks tutorials die gericht zijn op het herzien van de basisonderwerpen van de Java-taal om de lezer voor te bereiden op het gebruik van het Spring Framework. Het eerste deel van deze tutorialreeks kan hier worden verkregen en het tweede deel kan hier worden verkregen. In deze tutorial zullen we het hebben over wat interfaces zijn, wat programmeerinterfaces zijn, de voordelen ervan en hoe het zich verhoudt tot het Spring Framework.We hebben de concepten overerving en polymorfisme al gezien en interfaces zijn een type Java-klasse die wordt gekenmerkt door een bepaalde functionaliteit te vertegenwoordigen. In de meest voorkomende vorm zijn interfaces een klasse die bestaat uit methoden zonder implementatie.
interface Drawable {public void draw (); public void kies kleur (tekenreekskleur); } Interfaces zijn altijd openbaar en abstract, ongeacht of u modifiers instelt of niet, en vertegenwoordigen de manier waarop andere objecten omgaan met het object dat ze implementeert. Het klinkt misschien ingewikkeld, maar het is eenvoudig, wanneer een klasse een interface implementeert, wordt het gedwongen om een body te geven aan de corresponderende methoden. Dit betekent dat zolang een object een interface implementeert, u er volledig zeker van kunt zijn dat het object de methoden heeft die overeenkomen met de genoemde interface.
In Java worden interfaces geïmplementeerd met het trefwoord "implements" en een klasse kan een of meer interfaces implementeren, maar wordt gedwongen om de methoden die bij elke interface horen zonder uitzondering te overbelasten, anders geeft de compiler een fout.
public class Square implementeert Drawable {public String borderColor; public String vulkleur; publiek int hoog; openbare int breedte; @Override public void draw () {System.out.println ("Een vierkant wordt getekend met width" + width + ", height" + height + "and color" + fillcolor); } @Override public void chooseColor (String color) {fillcolor = color; }} public class Line implementeert Drawable {public String strokecolor; lange openbare String; @Override public void draw () {System.out.println ("Teken een lijn van" + lang); } @Override public void chooseColor (String color) {strokecolor = color; }} In dit geval stelt de interface je in staat om zonder problemen een willekeurig aantal objecten te manipuleren met behulp van het concept van polymorfisme dat we in het tweede deel zagen en deze objecten hoeven niet intrinsiek aan elkaar gerelateerd te zijn, behalve door de manier waarop andere klassen met elkaar omgaan met hen. In het geval van ons voorbeeld zou je later pentagon-, landscape- of zelfs ArtWork-objecten kunnen hebben die de Drawable-interface implementeren en ze kunnen allemaal worden afgehandeld door elke klasse die de Drawable-interface kan manipuleren.
java.awt.Kleur importeren; import java.util.*; public class DrawThings {// Deze klasse genereert willekeurig tekenbare objecten en tekent ze in willekeurige kleuren public static void main (String [] args) {List l = new ArrayList (); for (int i = 0; i0.5) {l.add (nieuwe regel ()); } else {l.add (nieuw vierkant ()); }} voor (Tekenbare d: l) {float H, S, B; H = (zwevend) Math.willekeurig (); S = (zwevend) Math.willekeurig (); B = (zwevend) Math.willekeurig (); Kleur c = Kleur.getHSBKleur (H, S, 
; d.chooseColor (String.valueOf (c)); d. tekenen (); }}} Zoals u in het voorbeeld zult zien, kan de hoofdmethode worden onderverdeeld in 2 hoofdmethoden, de methode die de lijst met tekenbare objecten vult en de methode die de objecten in de lijst tekent. Ik nodig je uit om deze klassen te gebruiken en te zien hoe ze zich gedragen voordat je doorgaat naar de volgende sectie waar we zullen zien waarom je de interface zou willen programmeren.
Uiteindelijk is een interface hetzelfde als zijn echte tegenhanger, je toetsenbord en je muis zijn de interfaces waarmee je met je computer communiceert, de interne details van hoe dingen als "Klik" of "Druk op de Esc-toets" worden uitgevoerd vanaf de interface naar uw computer zijn voor u verborgen en zijn niet nodig voor u. Het enige dat er toe doet, is dat u op de Esc-toets kunt drukken en kunt klikken met behulp van die interface.
Als je eenmaal hebt doorgenomen wat een interface is, hoop ik dat je begrijpt hoe belangrijk het kan zijn om er een te programmeren. In wezen concentreer je je op het maken van je programma's, denkend aan de interface die je gaat gebruiken en niet zozeer aan het object dat als parameter aan je zou worden doorgegeven. In het geval van het voorbeeld dat we tot nu toe hebben behandeld, kan het als volgt worden herschreven:
java.awt.Kleur importeren; import java.util.*; public class DrawThings {// Deze klasse genereert willekeurig tekenbare objecten en tekent ze in willekeurige kleuren public static void main (String [] args) {List l = new ArrayList (); vulLijst (l); drawLijst (l); } public static void fillList (Lijst l) {for (int i = 0; i0.5) {l.add (new Line ()); } else {l.add (nieuw vierkant ()); }}} openbare statische leegte drawList (Lijst l) {for (Tekenbare d: l) {float H, S, B; H = (zwevend) Math.willekeurig (); S = (zwevend) Math.willekeurig (); B = (zwevend) Math.willekeurig (); Kleur c = Kleur.getHSBKleur (H, S, ; d.chooseColor (String.valueOf (c)); d. tekenen (); }}} Ik heb zeker alleen de delen van de hoofdmethode gescheiden in de 2 onderliggende methoden, maar het mooie hiervan is dat die 2 methoden onafhankelijk van elkaar blijven en onafhankelijk blijven van de implementaties van de Drawable-interface. Als ik een van de 2 methoden zou willen wijzigen, zou de andere in het minst niet worden beïnvloed, als de Pentagon- en ArtWork-implementaties zouden verschijnen, zou je ze kunnen toevoegen tijdens het maken van de fillList (List l) -methode en de drawList ( List) methode. l) zouden geen wijzigingen nodig hebben omdat het in de interface is geprogrammeerd.
+ BelangrijkHet is dat beide methoden tot verschillende klassen kunnen behoren, ze kunnen in verschillende omgevingen worden behandeld en ze kunnen zelfs nooit weten welk object ze echt hanteren, maar zolang ze de Drawable-interface implementeren, zullen ze deze kunnen manipuleren en zullen ze in staat zijn om de 2 methoden uit te voeren die bij die interface horen.
Ik weet dat het op dit moment erg ingewikkeld lijkt, maar later zullen we zien hoe Spring alles verwerkt dat naar een interface is geprogrammeerd en we zullen zelfs zien hoe aspectgericht programmeren en begrijpen hiervan ons veel zal helpen om te begrijpen hoe Spring werkt.
Ik hoop dat we week na week doorgaan met deze tutorials, vergeet niet om je opmerkingen achter te laten tot de volgende keer!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
