interface enhancements java 8 java functional interface
Deze tutorial legt de toevoegingen aan de interface in Java 8 uit en de verschillen tussen Java-concepten zoals een abstracte klasse, uitbreidend trefwoord, enz. Met de interfaces:
We hebben er alles over onderzocht Interfaces in Java in onze laatste tutorial. We hebben de basisconcepten van interfaces in Java geïntroduceerd en behandeld, inclusief de meerdere interfaces.
Vóór Java 8 mochten interfaces alleen abstracte methoden en statische en laatste variabelen hebben. De abstracte methoden zijn standaard openbaar en moeten worden overschreven door de klasse die een interface implementeert.
Interface was dus voornamelijk een contract en hield zich alleen bezig met constanten (statisch en definitief) en abstracte methoden.
Bekijk hier de Java-beginnershandleiding.
Wat je leert:
- Interfaces Wijzigingen in Java 8
- Java 8 functionele interfaces
- Klasse versus interface in Java
- Java breidt versus werktuigen uit
- Interface versus abstracte klasse in Java
- Gevolgtrekking
Interfaces Wijzigingen in Java 8
De Java 8-release introduceert of stelt ons in staat om statische en standaardmethoden in de interfaces te hebben. Door standaardmethoden in een interface te gebruiken, kunnen de ontwikkelaars meer methoden aan de interfaces toevoegen. Op deze manier verstoren of veranderen ze de klassen die de interface implementeren niet.
Met Java 8 kan de interface ook een statische methode hebben. Statische methoden zijn dezelfde als die we definiëren in klassen. Merk op dat de statische methode niet kan worden overschreven door de klasse die de interface implementeert.
De introductie van statische en standaardmethoden in de interface maakte het gemakkelijker om de interfaces zonder problemen te wijzigen en maakte het ook gemakkelijker om interfaces te implementeren.
Java 8 introduceert ook 'Lambda Expressions' in functionele interfaces. Bovendien zijn er vanaf Java 8 meer ingebouwde functionele interfaces in Java toegevoegd.
In deze tutorial zullen we al deze toevoegingen aan de interfaces in Java 8 bespreken en zullen we ook enkele verschillen bespreken tussen verschillende Java-concepten zoals abstracte klassen, uitbreidingen sleutelwoorden, enz. Met de interfaces.
Statische methode in interface in Java
Interfaces kunnen ook methoden hebben die definities kunnen hebben. Dit zijn de statische methoden in de interface. De statische methoden zijn gedefinieerd in de interface en kunnen niet worden overschreven of gewijzigd door de klassen die deze interface implementeren.
We kunnen deze statische methoden aanroepen door rechtstreeks de interfacenaam te gebruiken.
Het volgende voorbeeld toont het gebruik van de statische methode.
Uitgang:
Het bovenstaande programma heeft een TestInterface. Het heeft een statische methode genaamd ‘static_print’ en ook een niet-statische methode genaamd de niet-statische methode.
We hebben de TestInterface in TestClass geïmplementeerd en nonStaticMethod overschreven. Vervolgens roepen we in de hoofdmethode de static_print-methode rechtstreeks aan met behulp van de TestInterface en nonStaticMethod met behulp van het object van de TestClass.
Interface standaardmethode
Zoals eerder vermeld, stonden interfaces vóór Java 8 alleen abstracte methoden toe. Dan zouden we deze methode-implementatie in een aparte klasse aanbieden. Als we een nieuwe methode aan de interface moesten toevoegen, dan moeten we de implementatiecode ervan in dezelfde klasse opgeven.
Dus als we de interface zouden veranderen door er een methode aan toe te voegen, zou de implementatieklasse ook veranderen.
Deze beperking werd overwonnen door de Java 8-versie die het mogelijk maakte dat de interfaces standaardmethoden hadden. De standaardmethoden bieden in zekere zin achterwaartse compatibiliteit met de bestaande interfaces en we hoeven de implementatieklasse niet te wijzigen. De standaardmethoden staan ook bekend als 'virtuele uitbreidingsmethode' of 'verdedigingsmethoden'.
Standaardmethoden worden gedeclareerd door het sleutelwoord “default” in de declaratie te gebruiken. De declaratie wordt gevolgd door de definitie van de methode. We kunnen de standaardmethode overschrijven, aangezien deze beschikbaar is voor de klasse die de interface implementeert.
Op dezelfde manier kunnen we het aanroepen met behulp van het implementatieklasse-object rechtstreeks vanuit de interface zonder het te overschrijven.
Uitgang:
wat is objectrepository in qtp
Het bovenstaande Java-programma demonstreert de standaardmethode in de interface. Merk in de hoofdmethode op dat we de standaardmethode van de interface kunnen aanroepen met behulp van het class-object. Dit komt doordat terwijl de klasse de interface implementeert, de standaardmethode ook voor de klasse beschikbaar is.
Notitie: We hadden de methode print () ook in de implementatieklasse kunnen overschrijven. Merk op dat als dit wordt overschreven, de toegangsmodificator van de standaardmethode in de implementatieklasse verandert in openbaar.
Standaardmethoden en meervoudige overerving
Er kan een situatie ontstaan in het geval van meerdere interfaces waarbij elke interface een standaardmethode heeft met hetzelfde prototype. In dat geval weet de compiler niet welke methode hij moet aanroepen.
Wanneer deze situatie zich voordoet waarin de standaardmethode hetzelfde prototype heeft in alle interfaces, dan is de oplossing om de methode in de implementatieklasse te overschrijven, zodat wanneer het implementatieklasseobject de standaardmethode aanroept, de compiler de methode aanroept die in de klasse is geïmplementeerd .
Het volgende Java-programma demonstreert het gebruik van de standaardmethode met meerdere interfaces.
Uitgang:
In het bovenstaande programma hebben we de standaardmethode (die hetzelfde prototype in beide interfaces heeft) in de implementatieklasse overschreven. Op deze manier, wanneer we de standaardmethode aanroepen vanuit de hoofdmethode met behulp van het object van de implementatieklasse, wordt de overschreven methode aangeroepen.
Java 8 functionele interfaces
Een functionele interface is een interface met slechts één abstracte methode. Het kan een willekeurig aantal standaard- en statische methoden bevatten, maar de abstracte methode die het bevat, is er precies één. Bovendien kan een functionele interface declaraties van objectklassemethoden hebben.
Functionele interface staat bekend als ' Interface voor enkele abstracte methode 'Of' SAM-interface SAM-interface is een nieuwe functie in Java.
open .jar-bestanden windows 10
In een Java-programma wordt de aanwezigheid van een functionele interface aangegeven door een @FunctionalInterface annotatie. Wanneer de compiler deze annotatie tegenkomt, weet hij dat de interface die op deze annotatie volgt functioneel is. Als het dus meer dan één abstracte methode bevat, wordt er een fout weergegeven.
De annotatie @FunctionalInterface is echter niet verplicht in Java.
Het volgende programma demonstreert de functionele interface in Java:
Uitgang:
De functionele interface in het bovenstaande programma heeft een enkele abstracte methode en heeft ook een objectklassemethode-declaratie zoals hashCode, toString en is gelijk aan. In de klasse die deze interface implementeert, wordt de abstracte methode overschreven. In de hoofdmethode maken we een object van de implementatieklasse en gebruiken we de methode.
Interfaces zoals Runnable en Comparable zijn voorbeelden van functionele interfaces in Java. Met Java 8 kunnen we lambda-expressies toewijzen aan het functionele interface-object.
Het volgende voorbeeldprogramma laat dit zien.
Uitgang:
Java 8 biedt ook veel ingebouwde functionele interfaces in het pakket java.util.function.
Deze ingebouwde interfaces worden hieronder beschreven:
# 1) Predikaat
Dit is een functionele interface in Java met een enkele abstracte methodetest. De ‘test’ -methode retourneert de booleaanse waarde na het testen van het opgegeven argument.
Hieronder is het prototype weergegeven voor de testmethode van de Predicate-interface.
# 2) BinaryOperator
De BinaryOperator-interface biedt een abstracte methode ‘toepassen’ die twee argumenten accepteert en een resulterende waarde retourneert van hetzelfde type als de argumenten.
Het prototype voor de acceptatiemethode is:
# 3) Functie
De functie-interface is een functionele interface die ook een abstracte methode heeft met de naam ‘toepassen’. Deze methode van toepassen heeft echter één argument van het type T en retourneert een waarde van het type R.
Het prototype van de toepassingsmethode is als volgt:
Het volgende Java-programma demonstreert het bovenstaande ingebouwde functionele interfacepredikaat.
Uitgang:
Zoals we in het bovenstaande programma kunnen zien, hebben we een lijst met strings. Met behulp van de functionele interface Predicaat testen we of het item in de string begint met M en zo ja, dan wordt de naam afgedrukt.
Klasse versus interface in Java
Hoewel klasse en interface vergelijkbaar zijn omdat ze een vergelijkbare syntaxis hebben, hebben deze twee entiteiten meer verschillen dan overeenkomsten.
Laten we enkele verschillen tussen klasse en interface in Java op een rijtje zetten.
| Klasse | Koppel |
|---|---|
| We kunnen objecten uit een klasse instantiëren en maken. | Een interface kan niet worden geïnstantieerd. |
| Het trefwoord ‘klas’ wordt gebruikt om een klas te maken. | De interface is gemaakt met het trefwoord ‘interface’. |
| Klassen ondersteunen geen meervoudige overerving in Java. | Interfaces ondersteunen meervoudige overerving in Java. |
| De klasse bevat de constructors. | Interfaces bevatten geen constructors. |
| De klasse kan geen abstracte methoden bevatten. | Interfaces bevatten alleen abstracte methoden. |
| De klasse kan variabelen en methoden hebben die standaard, openbaar, privé of beveiligd zijn. | De interface heeft standaard alleen openbare variabelen en methoden. |
| Het is niet verplicht om niet-toegangsmodificatoren te associëren met variabelen van de klasse. | Interfaces kunnen variabelen hebben die statisch of definitief zijn. |
| We kunnen een andere klasse erven van een klasse. | We kunnen geen klasse overnemen van de interface. |
| De klasse kan worden overgeërfd met het zoekwoord ‘extends’. | De interface kan worden geïmplementeerd door een andere klasse met behulp van het trefwoord ‘implementaties’. Het kan worden overgenomen door een andere interface met het zoekwoord ‘extends’. |
Java breidt versus werktuigen uit
| ‘Verlengt’ | ‘Werktuigen’ |
|---|---|
| Interfaces ondersteunen alleen statische en laatste niet-toegangsmodificatoren. | Abstract ondersteunt alle niet-toegangsmodificatoren zoals statisch, definitief, niet-statisch en niet-definitief. |
| Een klasse gebruikt het trefwoord ‘extends’ om te erven van een andere klasse. | Het trefwoord ‘implementaties’ wordt door een klas gebruikt om een interface te implementeren. |
| Een klasse die een andere klasse erft, kan al dan niet alle methoden van de bovenliggende klasse overschrijven. | De klasse die de interface implementeert, moet alle abstracte methoden van de interface overschrijven. |
| We kunnen slechts één klasse tegelijk uitbreiden met het trefwoord extends. | We kunnen meerdere interfaces implementeren met het zoekwoord ‘implementaties’. |
| Een interface kan een andere interface uitbreiden met het trefwoord ‘extends’. | Een interface kan geen andere interface implementeren met behulp van ‘implementaties'-zoekwoorden. |
Kan abstracte klasse interface in Java implementeren
Ja, een abstracte klasse kan een interface implementeren met het trefwoord ‘implementeert’. De abstracte klasse hoeft niet alle abstracte interface-methoden te implementeren. Maar over het algemeen is het een goede ontwerppraktijk om een interface te hebben met alle abstracte methoden, dan een abstracte klasse die deze interface implementeert, en dan de concrete klassen.
Hieronder wordt een voorbeeld gegeven van een dergelijke implementatie in Java.
Hier is java.util.List een interface. Deze interface is geïmplementeerd door java.util.AbstractList. Vervolgens wordt deze klasse AbstractList uitgebreid met twee concrete klassen, namelijk LinkedList en ArrayList.
Als de klassen LinkedList en ArrayList de List-interface rechtstreeks hadden geïmplementeerd, dan zouden ze alle abstracte methoden van de List-interface moeten implementeren.
Maar in dit geval implementeert de klasse AbstractList de methoden van de List-interface en geeft deze door aan LinkedList en ArrayList. Dus hier krijgen we het voordeel van het declareren van type vanuit de interface en abstracte klassenflexibiliteit om het algemene gedrag te implementeren.
Wanneer abstracte klasse en interface in Java gebruiken
We gebruiken voornamelijk een abstracte klasse om een standaardgedrag of algemeen gedrag van de onderliggende klassen te definiëren dat zich uitstrekt van deze abstracte klasse. Een interface wordt gebruikt om een contract te definiëren tussen twee systemen die samenwerken in een applicatie.
Bepaalde specifieke situaties zijn ideaal voor het gebruik van interfaces en bepaalde problemen die alleen met abstracte klassen kunnen worden opgelost. In deze sectie zullen we bespreken wanneer we de interface kunnen gebruiken en wanneer we abstracte klassen kunnen gebruiken.
Wanneer moet u een interface gebruiken:
- Interfaces worden voornamelijk gebruikt als we een kleine beknopte functionaliteit moeten implementeren.
- Wanneer we API's implementeren en we weten dat ze een tijdje niet zullen veranderen, dan gaan we die keer voor interfaces.
- Interfaces stellen ons in staat om meerdere overervingen te implementeren. Wanneer we dus meerdere overervingen in onze applicatie moeten implementeren, gaan we voor interfaces.
- Als we een breed scala aan objecten hebben, zijn interfaces opnieuw een betere keuze.
- Ook wanneer we een gemeenschappelijke functionaliteit moeten bieden aan veel niet-gerelateerde klassen, worden nog steeds interfaces gebruikt.
Wanneer gebruik je een abstracte klasse:
- Abstracte klassen worden voornamelijk gebruikt wanneer we overerving in onze applicatie moeten gebruiken.
- Aangezien interfaces omgaan met openbare methoden en variabelen, gebruiken we abstracte klassen wanneer we niet-openbare toegangsmodificatoren in ons programma willen gebruiken.
- Als er nieuwe methoden moeten worden toegevoegd, is het beter om dit in een abstracte klasse te doen dan in een interface. Omdat als we een nieuwe methode in de interface toevoegen, de volledige implementatie verandert, aangezien interfaces alleen methode-prototypes hebben en klasse-implementatie met behulp van de interface de implementatie zal bieden.
- Als we verschillende versies willen van de componenten die worden ontwikkeld, dan gaan we voor abstracte klasse. We kunnen abstracte klassen gemakkelijker veranderen. Maar interfaces kunnen niet worden gewijzigd. Als we een nieuwe versie willen, moeten we de hele interface opnieuw schrijven.
- Als we een gemeenschappelijke implementatie voor alle componenten willen bieden, is de abstracte klasse de beste keuze.
Interface versus abstracte klasse in Java
Hieronder vindt u enkele van de verschillen tussen interfaces en abstracte klassen in Java.
| Koppel | Abstracte klasse |
|---|---|
| Een interface wordt gedeclareerd met het trefwoord ‘interface’. | Een abstracte klasse wordt gedeclareerd met het trefwoord ‘abstract’. |
| De interface kan worden geïmplementeerd met het trefwoord ‘implementaties’. | De samenvatting kan worden overgeërfd met het trefwoord ‘extends’. |
| Een interface kan een klasse niet uitbreiden of een interface implementeren, het kan alleen een andere interface uitbreiden. | Een abstracte klasse kan een klasse uitbreiden of meerdere interfaces implementeren. |
| Interface-leden kunnen alleen openbaar zijn. | Abstracte klasleden kunnen openbaar, privé of beschermd zijn. |
| Een interface kan niet worden gebruikt om een implementatie te bieden. Het kan alleen als aangifte worden gebruikt. | Een abstracte klasse kan worden gebruikt voor het implementeren van de interface. |
| Meerdere overerving kan worden bereikt met behulp van interfaces. | De abstracte klasse ondersteunt geen meervoudige overerving. |
| Interfaces kunnen alleen abstracte methoden hebben. Vanaf Java 8 kan het statische en standaardmethoden hebben. | Een abstracte klasse kan een abstracte of niet-abstracte methode hebben. |
Enum Overerving in Java
We hebben enum-gegevenstypen besproken in onze discussie over gegevenstypen in Java. Alle enums zijn afkomstig van de klasse java.lang.Enum. Deze klasse java.lang.Enum is een abstracte klasse.
Bovendien zijn alle enum-klassen in Java standaard ‘final’. Een poging om een klasse over te nemen van een enum-klasse resulteert dus in een compilatiefout.
Aangezien Java geen meervoudige overerving toestaat, kunnen we de enum-klasse niet overnemen van een andere klasse, aangezien de enum-klasse al erft van java.lang.Enum. Enum-klassen kunnen echter interfaces in Java implementeren en dit wordt Enum-overerving in Java genoemd.
Hieronder wordt een voorbeeld gegeven van Enum Inheritance in Java.
Uitgang:
Hier hebben we een interface WeekDays met een abstracte methode prototype displaydays (). Vervolgens definiëren we een opsommingsklasse Dagen die de WeekDays-interface implementeert. Hier definiëren we opsommingswaarden van ZONDAG tot ZATERDAG en overschrijven we ook de weergavedagen-methode.
Ten slotte openen we in de hoofdmethode de enum-waarde en geven deze weer.
Veel Gestelde Vragen
V # 1) Wat gebeurt er als je de body van een methode in de interface geeft?
Antwoord: Voor Java-versies vóór Java 8 is de body van de methode niet toegestaan in de interface. Maar sinds Java 8 kunnen we een standaardmethode of statische methoden in de interface definiëren.
V # 2) Kan een interface variabelen hebben in Java 8?
Antwoord: We kunnen constante variabelen hebben in Java 8 met behulp van statische en laatste modificatoren. Maar we kunnen geen instantievariabelen hebben in Java-interfaces. Elke poging om instantievariabelen in een interface te declareren, zal resulteren in een compilatiefout.
V # 3) Wat zijn de verbeteringen in interfaces in Java 8?
Antwoord: De belangrijkste verbetering voor interfaces in Java 8 is dat statische en standaardmethoden zijn toegestaan in interfaces. We kunnen methoden hebben gedeclareerd als statisch of standaard en deze binnen de interface definiëren.
V # 4) Kunnen we de standaardmethode in de Java-interface overschrijven?
Antwoord: Nee. Het is niet verplicht om de standaardmethode in de interface te overschrijven. Dit komt doordat wanneer we een interface in een klasse implementeren, de standaardmethode van de klasse toegankelijk is voor de implementatieklasse. Door het object van de implementatieklasse te gebruiken, hebben we toegang tot de standaardmethode van de interface.
V # 5) Kunnen interfaces velden hebben in Java?
voer .jar-bestanden uit windows 10
Antwoord: Ja, we kunnen velden of variabelen hebben in interfaces in Java, maar standaard zijn al deze velden statisch, definitief en openbaar.
Gevolgtrekking
In deze tutorial hebben we de wijzigingen besproken die zijn aangebracht in interfaces in Java 8. Java 8 introduceerde statische en standaardmethoden in interfaces. Eerder konden we alleen abstracte methoden in de interface hebben. Maar vanaf Java 8 kunnen we standaard- en statische methoden in Java definiëren.
Ook maakt Java 8 het gebruik van lambda-expressies met de functionele interfaces in Java mogelijk. Vervolgens bespraken we ook abstracte klassen en interfaces en zagen we wanneer we ze allemaal in Java moesten gebruiken. We hebben ook de enum-overerving gezien in Java.
We hebben ook enkele verschillen besproken tussen uitbreidingen en implementaties, klasse en interface, abstracte klasse en interface, enz.
Bekijk hier ALLE Java-tutorials.
Aanbevolen literatuur
- Java-interface en abstracte les met voorbeelden
- Vergelijkbare en vergelijkende interfaces in Java
- ListIterator-interface in Java met voorbeelden
- Set-interface in Java: Java-zelfstudie met voorbeelden
- Markeringsinterface in Java: serialiseerbaar en kloneerbaar
- Java String length () Methode met voorbeelden
- Java-implementatie: creatie en uitvoering van Java JAR-bestand
- Hoe de Java toString-methode te gebruiken?