interface enhancements java 8 java functional interface
Denne vejledning forklarer tilføjelserne til grænsefladen i Java 8 og forskelle mellem Java-begreber som en abstrakt klasse, udvider søgeord osv. Med grænsefladerne:
Vi udforskede alt om Grænseflader i Java i vores sidste tutorial. Vi har introduceret og dækket de grundlæggende koncepter for grænseflader i Java inklusive de mange grænseflader.
Før Java 8 fik grænseflader kun tilladelse til at have abstrakte metoder og statiske og endelige variabler. De abstrakte metoder er som standard offentlige og skal tilsidesættes af den klasse, der implementerer en grænseflade.
Så interface var hovedsageligt en kontrakt og var kun involveret i konstanter (statisk og endelig) og abstrakte metoder.
=> Se på Java Beginners Guide her.
Hvad du vil lære:
- Grænsefladesændringer i Java 8
- Java 8 funktionelle grænseflader
- Klasse Vs-interface i Java
- Java udvider Vs-implementeringer
- Interface mod abstrakt klasse i Java
- Konklusion
Grænsefladesændringer i Java 8
Java 8-udgivelsen introducerer eller tillader os at have statiske metoder og standardmetoder i grænsefladerne. Ved hjælp af standardmetoder i en grænseflade kan udviklerne tilføje flere metoder til grænsefladerne. På denne måde forstyrrer eller ændrer de ikke de klasser, der implementerer grænsefladen.
Java 8 tillader også, at grænsefladen har en statisk metode. Statiske metoder er de samme som dem, vi definerer i klasser. Bemærk, at den statiske metode ikke kan tilsidesættes af den klasse, der implementerer grænsefladen.
Indførelsen af statiske og standardmetoder i grænsefladen gjorde det lettere at ændre grænsefladerne uden problemer og gjorde grænseflader også lettere at implementere.
Java 8 introducerer også 'Lambda Expressions' i funktionelle grænseflader. Derudover er der fra Java 8 og mere indbyggede funktionelle grænseflader tilføjet i Java.
I denne vejledning diskuterer vi alle disse tilføjelser til grænsefladerne i Java 8 og diskuterer også nogle af forskellene mellem forskellige Java-begreber som abstrakte klasser, udvider nøgleord osv. Med grænsefladerne.
Statisk metode i interface i Java
Grænseflader kan også have metoder, der kan have definitioner. Dette er de statiske metoder i grænsefladen. De statiske metoder er defineret inde i grænsefladen, og de kan ikke tilsidesættes eller ændres af de klasser, der implementerer denne grænseflade.
Vi kan kalde disse statiske metoder direkte ved hjælp af grænsefladenavnet.
Følgende eksempel viser brugen af den statiske metode.
//interface declaration interface TestInterface { // static method definition static void static_print() { System.out.println('TestInterface::static_print ()'); } // abstract method declaration void nonStaticMethod(String str); } // Interface implementation class TestClass implements TestInterface { // Override interface method @Override public void nonStaticMethod(String str) { System.out.println(str); } } public class Main{ public static void main(String() args) { TestClass classDemo = new TestClass(); // Call static method from interface TestInterface.static_print(); // Call overridden method using class object classDemo.nonStaticMethod('TestClass::nonStaticMethod ()'); } } Produktion:
Ovenstående program har en TestInterface. Den har en statisk metode ved navn 'static_print' og også en ikke-statisk metode med navnet nonstaticmethod.
Vi har implementeret TestInterface i TestClass og tilsidesat nonStaticMethod. Så i hovedmetoden kalder vi metoden static_print direkte ved hjælp af TestInterface og nonStaticMethod ved hjælp af objektet i TestClass.
Interface standardmetode
Som allerede nævnt tillod grænseflader før Java 8 kun abstrakte metoder. Derefter leverer vi denne metodeimplementering i en separat klasse. Hvis vi skulle tilføje en ny metode til grænsefladen, er vi nødt til at give dens implementeringskode i samme klasse.
Derfor, hvis vi ændrede grænsefladen ved at tilføje en metode til den, ville implementeringsklassen også ændre sig.
Denne begrænsning blev overvundet af Java 8-versionen, der tillod grænsefladerne at have standardmetoder. Standardmetoderne giver på en måde bagudkompatibilitet til de eksisterende grænseflader, og vi behøver ikke ændre implementeringsklassen. Standardmetoderne er også kendt som 'virtuel udvidelsesmetode' eller 'forsvarsmetoder'.
Standardmetoder erklæres ved hjælp af nøgleordet 'standard' i erklæringen. Erklæringen efterfølges af definitionen af metoden. Vi kan tilsidesætte standardmetoden, da den er tilgængelig for den klasse, der implementerer grænsefladen.
På samme måde kan vi påberåbe det ved hjælp af implementeringsklasseobjektet direkte fra grænsefladen uden at tilsidesætte det.
interface TestInterface { // abstract method public void cubeNumber(int num); // default method default void print() { System.out.println('TestInterface :: Default method'); } } class TestClass implements TestInterface { // override cubeNumber method public void cubeNumber(int num) { System.out.println('Cube of given number ' + num+ ':' + num*num*num); } } class Main{ public static void main(String args()) { TestClass obj = new TestClass(); obj.cubeNumber(5); // call default method print using class object obj.print(); } } Produktion:
hvordan man tester webstedet i forskellige browsere
Ovenstående Java-program viser standardmetoden i grænsefladen. I hovedmetoden skal du bemærke, at vi kan kalde standardmetoden til grænsefladen ved hjælp af klasseobjektet. Dette skyldes, at da klassen implementerer grænsefladen, er standardmetoden også tilgængelig for klassen.
Bemærk: Vi kunne have tilsidesat udskrivningsmetoden () også i implementeringsklassen. Bemærk, at hvis ændringen ændres, ændres adgangsmodifikatoren for standardmetoden til offentlig i implementeringsklassen.
Standardmetoder og flere arv
Der kan opstå en situation i tilfælde af flere grænseflader, hvor hver grænseflade muligvis har en standardmetode med den samme prototype. I et sådant tilfælde ved compileren ikke, hvilken metode der skal påberåbes.
Når denne situation opstår, hvor standardmetoden har den samme prototype i alle grænsefladerne, er løsningen at tilsidesætte metoden i implementeringsklasse, så når implementeringsklasseobjektet kalder standardmetoden, påkalder compileren metoden implementeret i klassen .
Følgende Java-program demonstrerer brugen af standardmetoden med flere grænseflader.
//Interface_One interface Interface_One{ //defaultMethod default void defaultMethod(){ System.out.println('Interface_One::defaultMethod'); } } //Interface_Two interface Interface_Two{ //defaultMethod default void defaultMethod(){ System.out.println('Interface_Two::defaultMethod'); } } class TestExample implements Interface_One, Interface_Two{ public void disp(String str){ System.out.println('String is: '+str); } //override defaultMethod to take care of the ambiguity public void defaultMethod(){ System.out.println('TestExample::defaultMethod'); } } class Main{ public static void main(String() args) { TestExample obj = new TestExample(); //call the default method obj.defaultMethod(); } }Produktion:
I ovenstående program har vi tilsidesat standardmetoden (som har den samme prototype i begge grænsefladerne) i implementeringsklassen. Denne måde, når vi kalder standardmetoden fra hovedmetoden ved hjælp af objektet fra implementeringsklassen, påkræves den tilsidesatte metode.
Java 8 funktionelle grænseflader
En funktionel grænseflade er en grænseflade, der kun har en abstrakt metode. Det kan indeholde et vilkårligt antal standard- og statiske metoder, men den abstrakte metode, den indeholder, er nøjagtigt en. Derudover kan en funktionel grænseflade have erklæringer om objektklassemetoder.
Funktionelt interface er kendt som “ Single Abstract Method Interface ”Eller“ SAM-interface ”. SAM-interface er en ny funktion i Java.
I et Java-program angives tilstedeværelsen af en funktionel grænseflade ved hjælp af en @FunktionelInterface kommentar. Når compileren støder på denne kommentar, ved den, at grænsefladen, der følger denne kommentar, er funktionel. Derfor, hvis den indeholder mere end en abstrakt metode, blinker den en fejl.
Kommentar @FunktionelInterface er dog ikke obligatorisk i Java.
Følgende program demonstrerer det funktionelle interface i Java:
//declare a functional interface @FunctionalInterface //annotation indicates it’s a functional interface interface function_Interface{ void disp_msg(String msg); // abstract method // Object class methods. int hashCode(); String toString(); boolean equals(Object obj); } //implementation of Functional Interface class FunctionalInterfaceExample implements function_Interface{ public void disp_msg(String msg){ System.out.println(msg); } } class Main{ public static void main(String() args) { //create object of implementation class and call method FunctionalInterfaceExample finte = new FunctionalInterfaceExample(); finte.disp_msg('Hello, World!!!'); } } Produktion:
Den funktionelle grænseflade i ovenstående program har en enkelt abstrakt metode og har også en erklæring om objektklassemetode som hashCode, toString og lig. I den klasse, der implementerer denne grænseflade, tilsidesættes den abstrakte metode. I hovedmetoden opretter vi et objekt fra implementeringsklassen og bruger metoden.
hvad er komponenterne i Java-platformen?
Grænseflader som Runnable og Comparable er eksempler på funktionelle grænseflader, der leveres i Java. Java 8 giver os mulighed for at tildele lambda-udtryk til det funktionelle interface-objekt.
Det følgende eksempelprogram viser dette.
class Main{ public static void main(String args()) { // use lambda expression to create the object new Thread(()-> {System.out.println('New thread created with functional interface');}).start(); } } Produktion:
Java 8 indeholder også mange indbyggede funktionelle grænseflader i java.util.function-pakken.
Disse indbyggede grænseflader er beskrevet nedenfor:
# 1) Prædikat
Dette er en funktionel grænseflade i Java, der har en enkelt abstrakt metodetest. Metoden 'test' returnerer den boolske værdi efter test af det angivne argument.
Nedenfor er prototypen til testmetoden til Predicate-grænsefladen.
public interface Predicate { public boolean test(T t); }# 2) BinaryOperator
BinaryOperator-interface giver en abstrakt metode 'anvend', som accepterer to argumenter og returnerer en resulterende værdi af samme type som argumenterne.
Prototypen for acceptmetoden er:
public interface BinaryOperator { public T apply (T x, T y); }# 3) Funktion
Funktionsgrænsefladen er en funktionel grænseflade, der også har en abstrakt metode kaldet 'anvend'. Denne anvendelsesmetode tager dog et enkelt argument af typen T og returnerer en værdi af typen R.
Prototypen for anvendelsesmetoden er som følger:
public interface Function { public R apply(T t); }Følgende Java-program demonstrerer ovenstående indbyggede funktionelle interface-forudsætning.
import java.util.*; import java.util.function.Predicate; class Main { public static void main(String args()) { // create a list of strings List names = Arrays.asList('Karen','Mia','Sydney','Lacey','Megan'); // declare string type predicate and use lambda expression to create object Predicate p = (s)->s.startsWith('M'); System.out.println('Names starting with M:'); // Iterate through the list for (String st:names) { // test each entry with predicate if (p.test(st)) System.out.println(st); } } } Produktion:
Som vi kan se i ovenstående program har vi en liste over strenge. Ved hjælp af den funktionelle interface Predicate tester vi, om elementet i strengen starter med M, og hvis det gør det, udskriver det navnet.
Klasse Vs-interface i Java
Selvom klasse og interface er ens, da de har lignende syntaks, har disse to enheder flere forskelle end ligheder.
Lad os liste ned nogle af forskellene mellem klasse og interface i Java.
| Klasse | Interface |
|---|---|
| Vi kan instantiere og oprette objekter fra en klasse. | En grænseflade kan ikke instantieres. |
| Nøgleordet 'klasse' bruges til at oprette en klasse. | Interfacet oprettes ved hjælp af nøgleordet 'interface'. |
| Klasser understøtter ikke flere arv i Java. | Grænseflader understøtter flere arv i Java. |
| Klassen indeholder konstruktørerne. | Grænseflader indeholder ikke konstruktører. |
| Klassen kan ikke indeholde abstrakte metoder. | Grænseflader indeholder kun abstrakte metoder. |
| Klassen kan have variabler og metoder, der er standard, offentlige, private eller beskyttede. | Interfacet har kun offentlige variabler og metoder som standard. |
| Det er ikke obligatorisk at knytte modifikatorer, der ikke er adgang, til variabler i klassen. | Grænseflader kan have variabler, der enten er statiske eller endelige. |
| Vi kan arve en anden klasse fra en klasse. | Vi kan ikke arve en klasse fra grænsefladen. |
| Klassen kan arves ved hjælp af nøgleordet 'udvider'. | Interfacet kan implementeres af en anden klasse ved hjælp af nøgleordet 'implementerer'. Det kan arves af en anden grænseflade ved hjælp af 'udvider' nøgleord. |
Java udvider Vs-implementeringer
| 'Strækker sig' | 'Redskaber' |
|---|---|
| Grænseflader understøtter kun statiske og endelige modifikatorer uden adgang. | Abstrakt understøtter alle ikke-adgangsmodifikatorer som statisk, endelig, ikke-statisk og ikke-endelig. |
| En klasse bruger 'udvider' søgeord til at arve fra en anden klasse. | Nøgleordet 'implementerer' bruges af en klasse til at implementere en grænseflade. |
| En klasse, der arver en anden klasse, tilsidesætter måske ikke alle metoderne i den overordnede klasse. | Den klasse, der implementerer grænsefladen, skal tilsidesætte alle de abstrakte metoder i grænsefladen. |
| Vi kan kun udvide en klasse ad gangen ved hjælp af søgeordet extends. | Vi kan implementere flere grænseflader ved hjælp af nøgleordet 'implementerer'. |
| En grænseflade kan udvide en anden grænseflade ved hjælp af 'udvider' nøgleord. | En grænseflade kan ikke implementere en anden grænseflade ved hjælp af 'implementerer' nøgleord. |
Kan abstrakt klasseimplementeringsgrænseflade i Java
Ja, en abstrakt klasse kan implementere en grænseflade ved hjælp af nøgleordet 'implementerer'. Den abstrakte klasse behøver ikke implementere alle abstrakte interface-metoder. Men generelt er det en god designpraksis at have en grænseflade med alle abstrakte metoder, derefter en abstrakt klasse, der implementerer denne grænseflade, og derefter de konkrete klasser.
Nedenfor er et eksempel på en sådan implementering i Java.
Her er java.util.List en grænseflade. Denne grænseflade er implementeret af java.util.AbstractList. Derefter udvides denne AbstractList-klasse med to konkrete klasser, dvs. LinkedList og ArrayList.
Hvis LinkedList- og ArrayList-klasser havde implementeret List-grænsefladen direkte, ville de skulle implementere alle de abstrakte metoder i List-interface.
Men i dette tilfælde implementerer klassen AbstractList metoderne til List-interface og videregiver dem til LinkedList og ArrayList. Så her får vi fordelen ved at erklære type fra grænsefladen og abstrakt klassefleksibilitet ved implementering af den fælles adfærd.
Hvornår skal man bruge abstrakt klasse og interface i Java
Vi bruger hovedsageligt en abstrakt klasse til at definere en standard eller almindelig opførsel af barneklasser, der strækker sig fra denne abstrakte klasse. En grænseflade bruges til at definere en kontrakt mellem to systemer, der interagerer i en applikation.
Visse specifikke situationer er ideelle til brug af grænseflader og visse problemer, der kun kan løses ved hjælp af abstrakte klasser. I dette afsnit vil vi diskutere, hvornår vi kan bruge grænsefladen, og hvornår vi kan bruge abstrakte klasser.
Hvornår skal man bruge et interface:
- Grænseflader bruges hovedsageligt, når vi har en lille kortfattet funktionalitet at implementere.
- Når vi implementerer API'er, og vi ved, at de ikke vil ændre sig i et stykke tid, går vi den gang til grænseflader.
- Grænseflader giver os mulighed for at implementere flere arv. Derfor når vi har brug for at implementere flere arv i vores applikation, går vi efter grænseflader.
- Når vi har en bred vifte af objekter, er grænseflader igen et bedre valg.
- Også når vi skal levere en fælles funktionalitet til mange ikke-relaterede klasser, bruges der stadig grænseflader.
Hvornår skal man bruge en abstrakt klasse:
- Abstrakte klasser bruges hovedsageligt, når vi har brug for arv i vores applikation.
- Da grænseflader beskæftiger sig med offentlige metoder og variabler, når vi ønsker at bruge ikke-offentlige adgangsmodifikatorer i vores program, bruger vi abstrakte klasser.
- Hvis der skal tilføjes nye metoder, er det bedre at gøre det i en abstrakt klasse end i grænsefladen. Fordi hvis vi tilføjer en ny metode i grænsefladen, ændres hele implementeringen, da grænseflader kun har metodeprototyper, og klasseimplementering ved hjælp af grænsefladen giver implementeringen.
- Hvis vi vil have forskellige versioner af komponenterne udviklet, går vi til abstrakt klasse. Vi kan lettere ændre abstrakte klasser. Men grænseflader kan ikke ændres. Hvis vi vil have en ny version, skal vi skrive hele grænsefladen igen.
- Når vi ønsker at give en fælles implementering af alle komponenterne, er den abstrakte klasse det bedste valg.
Interface mod abstrakt klasse i Java
Nedenfor er nogle af forskellene mellem grænseflader og abstrakte klasser i Java.
| Interface | Abstrakt klasse |
|---|---|
| En grænseflade erklæres ved hjælp af nøgleordet 'interface'. | En abstrakt klasse erklæres ved hjælp af 'abstrakt' nøgleordet. |
| Interfacet kan implementeres ved hjælp af 'implementerer' nøgleordet. | Abstraktet kan arves ved hjælp af 'udvider' nøgleord. |
| En grænseflade kan ikke udvide en klasse eller implementere en grænseflade, den kan kun udvide en anden grænseflade. | En abstrakt klasse kan udvide en klasse eller implementere flere grænseflader. |
| Interface medlemmer kan kun være offentlige. | Abstrakte klassemedlemmer kan være offentlige, private eller beskyttede. |
| En grænseflade kan ikke bruges til at levere en implementering. Det kan kun bruges som en erklæring. | En abstrakt klasse kan bruges til at implementere grænsefladen. |
| Flere arv kan opnås ved hjælp af grænseflader. | Abstrakt klasse understøtter ikke flere arv. |
| Grænseflader kan kun have abstrakte metoder. Fra Java 8 kan den have statiske metoder og standardmetoder. | En abstrakt klasse kan have en abstrakt eller ikke-abstrakt metode. |
Enum arv i Java
Vi har diskuteret enum-datatyper i vores diskussion om datatyper i Java. Alle enums strækker sig fra java.lang.Enum klasse. Denne klasse java.lang.Enum er en abstrakt klasse.
Også alle enum-klasser i Java er som standard 'endelige'. Derfor resulterer et forsøg på at arve en klasse fra enumklasser i en kompilatorfejl.
Da Java ikke tillader flere arv, kan vi ikke arve enum-klasse fra nogen anden klasse, da enum-klasse allerede arver fra java.lang.Enum. Dog kan enum-klasser implementere grænseflader i Java, og dette kaldes Enum-arv i Java.
Nedenfor er et eksempel på Enum Arv i Java.
//WeekDays interface declaration interface WeekDays { public void displaydays(); } //enum class implementing WeekDays interface enum Days implements WeekDays { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,FRIDAY, SATURDAY; public void displaydays() { //Override displaydays method System.out.println('The day of the week: ' + this); } } class Main { public static void main(String() args) { Days.MONDAY.displaydays(); //access enum value } }Produktion:
Her har vi en grænseflade WeekDays med en abstrakt metode prototype displaydays (). Derefter definerer vi en enum klasse dage, der implementerer WeekDays interface. Her definerer vi enumværdier fra SUNDAG til LØRDAG og tilsidesætter også displaydags-metoden.
Endelig får vi i hovedmetoden adgang til enumværdien og viser den.
Ofte stillede spørgsmål
Spørgsmål nr. 1) Hvad sker der, hvis du giver en metodekroppe i grænsefladen?
Svar: For Java-versioner før Java 8 er metodens krop ikke tilladt i grænsefladen. Men siden Java 8 kan vi enten definere en standard eller statiske metoder inde i grænsefladen.
Q # 2) Kan en grænseflade have variabler i Java 8?
Svar: Vi kan have konstante variabler i Java 8 ved hjælp af statiske og endelige modifikatorer. Men vi kan ikke have instansvariabler i Java-grænseflader. Ethvert forsøg på at erklære instansvariabler i en grænseflade vil resultere i en compiler-fejl.
Q # 3) Hvad er forbedringerne i grænseflader i Java 8?
Svar: Den vigtigste forbedring for grænseflader i Java 8 er, at statiske metoder og standardmetoder er tilladt i grænseflader. Vi kan få metoder erklæret som statiske eller standardindstillinger og definere dem inde i grænsefladen.
Q # 4) Kan vi tilsidesætte standardmetoden i Java-grænsefladen?
Svar: Nej. Det er ikke obligatorisk at tilsidesætte standardmetoden i grænsefladen. Dette skyldes, at når vi implementerer en grænseflade i en klasse, er klassens standardmetode tilgængelig for implementeringsklassen. Derfor ved hjælp af objektet fra implementeringsklassen kan vi få adgang til standardmetoden for grænsefladen.
Q # 5) Kan grænseflader have felter i Java?
mp3 musik downloader app til android
Svar: Ja, vi kan have felter eller variabler i grænseflader i Java, men som standard er alle disse felter statiske, endelige og offentlige.
Konklusion
I denne vejledning har vi diskuteret de ændringer, der er foretaget i grænseflader i Java 8. Java 8 introducerede statiske og standardmetoder i grænseflader. Tidligere kunne vi kun have abstrakte metoder i grænsefladen. Men fra Java 8 og fremefter kan vi definere standard- og statiske metoder i Java.
Java 8 tillader også brugen af lambda-udtryk med de funktionelle grænseflader i Java. Derefter diskuterede vi også abstrakte klasser og grænseflader og så, hvornår de skulle bruges i Java. Vi har også set enum-arven i Java.
Vi diskuterede også nogle af forskellene mellem udvidelser og redskaber, klasse og interface, abstrakt klasse og interface osv.
=> Tjek ALLE Java-tutorials her.
Anbefalet læsning
- Java-interface og abstrakt klasseundervisning med eksempler
- Sammenlignelige og komparatorgrænseflader i Java
- ListIterator-interface i Java med eksempler
- Indstil interface i Java: Java Set-tutorial med eksempler
- Markørinterface i Java: Serialiserbar og klonbar
- Java strenglængde () Metode med eksempler
- Java-implementering: Oprettelse og udførelse af Java JAR-fil
- Sådan bruges Java toString-metoden?