java interface abstract class tutorial with examples
Deze video-tutorial legt uit wat Java-interface is, hoe het moet worden geïmplementeerd en meervoudige overerving met behulp van interfaces in Java met voorbeelden:
In een van onze eerdere tutorials hebben we abstractie in detail besproken. Daar bespraken we abstracte lessen en abstracte methoden. We weten dat abstracte klassen abstractie bieden, omdat we ook een niet-abstracte methode in de abstracte klasse kunnen hebben.
De functie die 100% abstractie in Java biedt, wordt ' Koppel In deze tutorial zullen we bespreken interfaces in Java.
Bekijk hier de Java-beginnershandleiding.
Wat je leert:
- Videotutorials over interfaces en abstracte lessen
- Wat is een interface in Java
- Meerdere interfaces in Java
- Gevolgtrekking
Videotutorials over interfaces en abstracte lessen
Inleiding tot interfaces en abstracte klassen in Java - Deel 1:
Overzicht van interfaces en abstracte klassen in Java - Deel 2:
Abstractie en overerving in Java:
Wat is een interface in Java
Een interface in Java wordt gedefinieerd als een abstract type dat klassengedrag specificeert. Een interface is een soort protocol dat regels opstelt met betrekking tot hoe een bepaalde klasse zich zou moeten gedragen.
Een interface in Java kan abstracte methoden en statische constanten bevatten. Standaard zijn alle methoden in de interface openbaar en abstract.
Een eenvoudig voorbeeld van een interface in Java wordt hieronder gegeven.
Het bovenstaande voorbeeld definieert een interface ‘vorm’ met een statische variabele en een abstracte methode ‘berekenArea ()’.
Een interface is een entiteit die alleen abstracte methoden als lichaam heeft. Het kan ook statische eindvariabelen bevatten.
Dus net als klasse kan een interface ook methoden en variabelen hebben, maar merk op dat de methoden abstract zijn (zonder implementatie) en dat variabelen statisch zijn.
Hieronder staan enkele eigenschappen die in gedachten moeten worden gehouden met betrekking tot interfaces:
- Interfaces zijn blauwdrukken voor een klas. Ze vertellen de klas wat ze moeten doen door middel van hun methoden.
- Een interface specificeert abstracte methoden en klassen die die interface implementeren, zouden die methoden ook moeten implementeren.
- Als een klasse die de interface implementeert niet alle methoden van de interface definieert, wordt die klasse een abstracte klasse.
De algemene syntaxis van de interfacedeclaratie wordt hieronder gegeven.
Zoals blijkt uit de bovenstaande verklaring, gebruiken we een Java-sleutelwoord 'interface' dat aangeeft dat we nu een interface declareren.
hoe statische variabele te initialiseren in c ++
Een ‘interface’ trefwoord wordt gevolgd door de interfacenaam en vervolgens de accolades die openen. Dan hebben we verschillende declaraties van abstracte methoden, statische velden declaratie, etc. Ten slotte sluiten we de accolades.
Bijvoorbeeld,als we een interface ‘TestInterface’ willen declareren met twee methoden erin, d.w.z. method_one en method_two, dan is de declaratie van TestInterface als volgt:
Gebruik van de interface in Java
- Interfaces in Java bieden 100% abstractie omdat ze alleen abstracte methoden kunnen hebben.
- Met behulp van interfaces kunnen we meerdere overervingen in Java bereiken, wat niet mogelijk is met klassen.
- Om een losse koppeling te krijgen, kan een interface worden gebruikt.
Hoe een interface in Java te implementeren
Zodra de interface is gedeclareerd, kunnen we deze in een klas gebruiken met behulp van het trefwoord 'implementeert' in de klasseverklaring.
Dit 'implementaties'-zoekwoord verschijnt na de klassenaam, zoals hieronder weergegeven:
Het implementeren van een interface is hetzelfde als het ondertekenen van een contract. Vandaar dat een klasse die een interface implementeert, betekent dat hij een contract heeft ondertekend en ermee heeft ingestemd de abstracte methoden van de interface te implementeren of met andere woorden het gedrag uit te voeren dat door de interface wordt gespecificeerd.
Als de klasse die de interface implementeert niet het exacte gedrag implementeert dat in de interface is gespecificeerd, moet de klasse als abstract worden gedeclareerd.
Voorbeeld van interface-implementatie
Hieronder wordt een eenvoudig voorbeeld gegeven van een interface in Java.
Uitgang:
Het bovenstaande programma demonstreert het eenvoudige voorbeeld van interfaces in Java. Hier declareren we een interface met de naam Polygon_Shape en vervolgens implementeert de klasse Rectangle deze.
Interface naamgevingsconventie in Java
Java-naamgevingsconventies zijn de naamgevingsrichtlijnen die we als programmeurs moeten volgen, zodat we leesbare consistente code kunnen produceren. Java gebruikt 'TitleCase' -notaties voor de naamgevingsklassen en interfaces. Het gebruikt 'CamelCase' -notaties voor variabelen, methoden, enz.
Wat de interface betreft, staat de interfacenaam in de titelletter, waarbij de eerste letter van elk woord van de interfacenaam een hoofdletter is. Interfacenamen worden zo gekozen dat het meestal bijvoeglijke naamwoorden zijn. Maar als interfaces de familie van klassen vertegenwoordigen, zoals map of lijst, dan kunnen ze naar zelfstandige naamwoorden worden genoemd.
Enkele voorbeelden van geldige interfacenamen worden hieronder gegeven:
Interface Constructor
De volgende vraag is of een interface een constructor heeft?
We weten dat we objecten nodig hebben om methoden op te roepen. Om objecten te maken hebben we constructeurs nodig. Maar in het geval van Interfaces in Java zijn de methoden niet geïmplementeerd.
De methoden van interfaces zijn allemaal abstract. Daarom heeft het geen zin om deze methoden vanuit de interface aan te roepen. Ten tweede, aangezien interfaces standaard abstract zijn, kunnen we geen objecten van de interface maken. We hebben dus geen constructors nodig voor Interface.
Interfacemethoden
In deze sectie zullen we bespreken hoe interfacemethoden kunnen worden gedeclareerd. Een interface kan per regel alleen openbare methoden hebben of standaard zijn interfacemethoden openbaar. Geen enkele andere toegangsmodificator mag binnen de interface worden gebruikt.
Dus of we het nu expliciet verklaren of niet, elke methode in de interface is standaard abstract met publieke zichtbaarheid.
Dus als void printMethod () het prototype is dat we in een interface willen declareren, dan zijn de volgende declaraties hetzelfde.
Merk op dat we de volgende modificatoren in de interface niet kunnen gebruiken voor de interfacemethoden.
- laatste
- statisch
- Privaat
- beschermd
- gesynchroniseerd
- native
- strictfp
Laten we nu een Java-programma implementeren om de zichtbaarheid van de interfacemethode te demonstreren.
Uitgang:
Zoals reeds vermeld, zijn de interfacemethoden standaard openbaar. Dus als we geen toegangsmodificator specificeren voor de interfacemethode, dan is deze openbaar zoals in het bovenstaande programma.
Stel dat we de interfacemethode-declaratie in het bovenstaande programma als volgt wijzigen:
privé leegte printMethod ();
Dit betekent dat we de interfacemethode printMethod () als privé hebben gespecificeerd. Wanneer we het programma compileren, krijgen we de volgende compilerfout.
fout: modifier privé is hier niet toegestaan
privé leegte printMethod ();
Het tweede geval dat we kunnen testen, is door de modifier van de geïmplementeerde methode in de klasse TestClass te veranderen van public naar private. Nu is de standaardmodifier in de klas privé. We verwijderen dus het openbare sleutelwoord uit het methode-prototype in de klasse als volgt:
Als we het programma nu compileren, krijgen we de volgende foutmelding.
fout: printMethod () in TestClass kan printMethod () niet implementeren in TestInterface
leegte printMethod ()
proberen om zwakkere toegangsprivileges toe te wijzen; was openbaar
Daarom moet hier worden opgemerkt dat we de toegangsmodificator van de geïmplementeerde methode van de interface niet kunnen veranderen in een andere toegangsmodificator. Aangezien de interfacemethoden standaard openbaar zijn, moeten deze methoden ook openbaar zijn wanneer ze worden geïmplementeerd door klassen die interfaces implementeren.
Interfacevelden in Java
De velden of variabelen die in een interface worden gedeclareerd, zijn standaard openbaar, statisch en definitief. Dit betekent dat hun waarde eenmaal gedeclareerd niet kan worden gewijzigd.
Merk op dat als de interfacevelden zijn gedefinieerd zonder een van deze modificatoren te specificeren, Java-compilers deze modificatoren aannemen. Bijvoorbeeld, als we geen openbare modifier specificeren bij het declareren van het veld in de interface, dan wordt dit standaard aangenomen.
Wanneer een interface wordt geïmplementeerd door een klasse, biedt het een implementatie voor alle abstracte methoden van de interface. Evenzo worden alle velden die in de interface zijn gedeclareerd, ook overgenomen door de klasse die de interface implementeert. Een kopie van het interfaceveld is dus aanwezig in de implementatieklasse.
Nu zijn alle velden in de interface standaard statisch. Daarom kunnen we ze openen door de interfacenaam rechtstreeks te gebruiken, net zoals we toegang hebben tot statische velden van de klasse met behulp van de klassenaam en niet het object.
Het onderstaande voorbeeld Java-programma laat zien hoe we toegang kunnen krijgen tot de interfacevelden.
Uitgang:
Zoals weergegeven in het programma hierboven, zijn de interfacevelden toegankelijk met een interfacenaam gevolgd door een puntoperator (.) En vervolgens de feitelijke variabele of veldnaam.
De algemene interface in Java
We hebben Java-generieke geneesmiddelen besproken in onze eerdere tutorials. Naast generieke klassen, methoden, enz., Kunnen we ook generieke interfaces hebben. Generieke interfaces kunnen op dezelfde manier worden gespecificeerd op de manier waarop we generieke klassen specificeren.
Generieke interfaces worden gedeclareerd met typeparameters waardoor ze onafhankelijk zijn van een datatype.
De algemene syntaxis van de generieke interface is als volgt:
datastage interviewvragen en antwoorden voor ervaren
Als we nu de bovenstaande generieke interface in een klas willen gebruiken, dan kunnen we dat hebben de klassendefinitie zoals hieronder weergegeven:
Merk op dat we dezelfde parameterlijst moeten specificeren met de klasse als met de interface.
Het volgende Java-programma demonstreert de generieke interfaces in Java.
Uitgang:
Het bovenstaande programma implementeert een interface met een methode om de minimumwaarde in de array te vinden. Dit is een generieke interface. De klasse implementeert deze interface en overschrijft de methode. In de hoofdmethode noemen we de interfacemethode om de minimumwaarde in een geheel getal en een tekenreeks te vinden.
Meerdere interfaces in Java
In ons overervingsonderwerp hebben we gezien dat Java niet toestaat dat een klasse erven van meerdere klassen, omdat dit resulteert in een dubbelzinnigheid die het 'diamantprobleem' wordt genoemd.
Een klasse kan echter meer dan één interface erven of implementeren. In dit geval staat het bekend als meervoudige overerving. Dus hoewel het ons niet is toegestaan om meerdere overerving in Java te implementeren via klassen, kunnen we dit doen met behulp van interfaces.
Het volgende diagram toont meervoudige overerving met behulp van interfaces. Hier implementeert een klasse twee interfaces, namelijk Interface_one en Interface_two.
Merk op dat wanneer een klasse de meerdere interfaces implementeert, de interfacenamen door komma's worden gescheiden in de klassendeclaratie. We kunnen zoveel interfaces implementeren als we de complexiteit aankunnen.
Het Java-programma dat meerdere interfaces demonstreert, wordt hieronder weergegeven.
Uitgang:
wat doet een bètatester
Zoals hierboven getoond, implementeren we twee interfaces. Vervolgens overschrijven we hun respectieve methoden en noemen ze in de hoofdmethode.
Meervoudige overerving in Java biedt alle voordelen die meervoudige overerving biedt in C ++. Maar in tegenstelling tot meervoudige overerving met behulp van klassen, is meervoudige overerving met behulp van interfaces ondubbelzinnig.
Interface-overerving in Java: interface breidt interface uit
Wanneer een klas een interface implementeert, wordt dit gedaan met behulp van de ‘ werktuigen ’Zoekwoord. In Java kan een interface een andere interface erven. Dit wordt gedaan met behulp van de ‘ strekt zich uit ’Zoekwoord. Wanneer een interface een andere interface uitbreidt, wordt deze ' Overerving van interface ”In Java.
Het Java-programma om interface-overerving te implementeren, wordt hieronder weergegeven.
Uitgang:
We hebben hetzelfde programma aangepast dat we gebruikten voor meervoudige overerving met behulp van interfaces om de overerving van de interface te demonstreren. Hier breiden we Interface_one uit in Interface_two en gaan we over op het implementeren van Interface_two in een klas. Aangezien interfaces worden overgenomen, kunnen beide methoden worden overschreven.
Veel Gestelde Vragen
V # 1) Wat is het gebruik van de interface in Java?
Antwoord: Een interface in Java is een entiteit die wordt gebruikt om 100% abstractie te bereiken. Het kan alleen abstracte methoden bevatten die kunnen worden overschreven door de klasse die de interface implementeert.
De interface fungeert in zekere zin als een blauwdruk van de klasse, waarbij het de klasse de prototypes van de abstracte methode en statische constanten biedt, en vervolgens moet de klasse die methoden overschrijven door de interface te implementeren.
Q # 2) Wat zijn de voordelen van de interface in Java?
Antwoord: Enkele voordelen van Interface zijn als volgt:
- De interface fungeert als een blauwdruk van de klas.
- De interface biedt 100% abstractie in Java omdat het alle abstracte methoden heeft.
- Interfaces kunnen worden gebruikt om meervoudige overerving in Java te bereiken. Java staat niet toe om van meer dan één klasse te erven, maar een klasse kan meerdere interfaces implementeren.
# 3) Kan een interface methoden hebben?
Antwoord: Interfaces kunnen prototypes van methoden en statische en eindconstanten hebben. Maar vanaf Java 8 kunnen interfaces statische en standaardmethoden bevatten.
V # 4) Kunnen we de interface als definitief verklaren?
Antwoord: Nee. Als we een interface als definitief verklaren, kan de klasse deze niet implementeren. Zonder geïmplementeerd te zijn door een klasse, zal de interface geen enkel doel dienen.
Meer over interfaces
Interfaces zijn blauwdrukken zoals klasse, maar het heeft alleen de methode-declaratie. Het heeft geen enkele implementatiemethode. Alle methoden in de interface zijn standaard openbaar abstract. De Java 1.8-interface kan statische en standaardmethoden hebben.
Interfaces worden voornamelijk gebruikt in API's.
Bijvoorbeeld: Bedenk dat u de motor van een voertuig ontwerpt.
Als u klaar bent met het hardwaregedeelte, wilt u dat sommige softwarefuncties worden geïmplementeerd door een klant die uw motor gebruikt. In dat geval kunt u uw engine-functionaliteiten dus in een interface definiëren.
Regels die moeten worden gevolgd voor Interface
- De klasse die de interface implementeert, moet alle methoden in de interface implementeren.
- Een interface kan laatste variabelen bevatten.
Hier is de voertuigklasse de subklasse die de motorinterface implementeert.
Wat zijn abstracte klassen?
Een abstracte klasse is als een klasse, maar het zal abstracte methoden en concrete methoden hebben. Abstracte methoden hebben geen implementatie. Het heeft alleen de methode-declaratie.
Regels die gevolgd moeten worden voor Abstract Class
- De abstracte klasse kan niet worden geïnstantieerd.
- De onderliggende klasse die de abstracte klasse uitbreidt, moet alle abstracte methoden van de bovenliggende klasse implementeren, of de klasse Child moet als een abstracte klasse worden gedeclareerd.
Wanneer u een deelimplementatie wilt ontwerpen, kunt u terecht voor een abstracte klasse.
Voorbeeld abstract klassenprogramma:
EmployeeDetails.java
De klasse die de abstracte klasse gaat uitbreiden.
HR.java
Belangrijkste punten om op te merken:
- In Interfaces hebben alle methoden geen methode-implementatie.
- De klasse die de interface implementeert, moet alle methoden in die specifieke interface implementeren.
- Abstracte klassen kunnen zowel abstracte methoden als normale concrete methoden hebben. Abstracte methoden hebben geen implementatie.
- De klasse die de abstracte klasse uitbreidt, moet de implementatie hebben voor alle abstracte methoden in de abstracte klasse.
- Als de subklasse niet genoeg informatie heeft om de abstracte methoden te implementeren, moet de subklasse worden gedeclareerd als een abstracte klasse.
Gevolgtrekking
In deze tutorial hebben we de basisconcepten van interfaces in Java gepresenteerd. We hebben de definitie van de interface besproken, samen met de behoefte aan interfaces. We hebben hun basissyntaxis en definitie onderzocht. Vervolgens hebben we besproken hoe we interfaces kunnen gebruiken waarvoor we het trefwoord ‘implementaties’ gebruiken.
We hebben geleerd hoe we meerdere interfaces en interface-overerving in Java kunnen gebruiken. Met behulp van meerdere interfaces kunnen we meerdere overerving in Java implementeren. Interface-overerving is wanneer een interface een andere interface uitbreidt.
Bezoek hier om de Java-trainingsserie voor iedereen te zien
Aanbevolen literatuur
- OOP Java: inleiding tot objectgeoriënteerd programmeren in Java
- Vergelijkbare en vergelijkende interfaces in Java
- Interfaceverbeteringen in Java 8 - Java functionele interface
- Zelfstudie voor Java-kaartinterface met implementatie en voorbeelden
- ListIterator-interface in Java met voorbeelden
- Markeringsinterface in Java: serialiseerbaar en kloneerbaar
- Set-interface in Java: Java-zelfstudie met voorbeelden
- Zelfstudie over reflectie in Java met voorbeelden