interface enhancements java 8 java functional interface
Denne opplæringen forklarer tilleggene til grensesnittet i Java 8 og forskjeller mellom Java-konsepter som en abstrakt klasse, utvider nøkkelord osv. Med grensesnittene:
Vi utforsket alt om Grensesnitt i Java i vår siste opplæring. Vi har introdusert og dekket de grunnleggende konseptene for grensesnitt i Java, inkludert flere grensesnitt.
Før Java 8 var grensesnitt tillatt å ha bare abstrakte metoder og statiske og endelige variabler. De abstrakte metodene er som standard offentlige og må overstyres av klassen som implementerer et grensesnitt.
Så grensesnittet var hovedsakelig en kontrakt og var bare involvert i konstanter (statisk og endelig) og abstrakte metoder.
=> Ta en titt på Java Beginners Guide her.
Hva du vil lære:
- Grensesnittendringer i Java 8
- Java 8 funksjonelle grensesnitt
- Klasse Vs-grensesnitt i Java
- Java utvider Vs-implementeringer
- Grensesnitt mot abstrakt klasse i Java
- Konklusjon
Grensesnittendringer i Java 8
Java 8-utgivelsen introduserer eller lar oss ha statiske og standardmetoder i grensesnittene. Ved å bruke standardmetoder i et grensesnitt kan utviklerne legge til flere metoder i grensesnittene. På denne måten forstyrrer de ikke eller endrer klassene som implementerer grensesnittet.
Java 8 lar også grensesnittet ha en statisk metode. Statiske metoder er de samme som de vi definerer i klasser. Merk at den statiske metoden ikke kan overstyres av klassen som implementerer grensesnittet.
Innføringen av statiske og standardmetoder i grensesnittet gjorde det lettere å endre grensesnittene uten problemer, og gjorde grensesnitt også enklere å implementere.
Java 8 introduserer også 'Lambda Expressions' i funksjonelle grensesnitt. Dessuten er det fra Java 8 flere innebygde funksjonelle grensesnitt lagt til i Java.
I denne opplæringen vil vi diskutere alle disse tilleggene til grensesnittene i Java 8, og vil også diskutere noen av forskjellene mellom forskjellige Java-konsepter som abstrakte klasser, utvider søkeord, etc. med grensesnittene.
Statisk metode i grensesnitt i Java
Grensesnitt kan også ha metoder som kan ha definisjoner. Dette er de statiske metodene i grensesnittet. De statiske metodene er definert inne i grensesnittet, og de kan ikke overstyres eller endres av klassene som implementerer dette grensesnittet.
Vi kan kalle disse statiske metodene ved å bruke grensesnittnavnet direkte.
Følgende eksempel viser bruken av den statiske metoden.
//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 ()'); } } Produksjon:
Ovennevnte program har en TestInterface. Den har en statisk metode kalt ‘static_print’ og også en ikke-statisk metode som heter nonstaticmethod.
Vi har implementert TestInterface i TestClass og overstyrt nonStaticMethod. Så i hovedmetoden kaller vi static_print-metoden direkte ved hjelp av TestInterface og nonStaticMethod ved hjelp av objektet til TestClass.
Grensesnittets standardmetode
Som allerede nevnt tillot grensesnitt før Java 8 bare abstrakte metoder. Deretter vil vi gi denne metoden implementering i en egen klasse. Hvis vi måtte legge til en ny metode i grensesnittet, må vi oppgi implementeringskoden for den i samme klasse.
Derfor, hvis vi endret grensesnittet ved å legge til en metode for det, ville implementeringsklassen også endres.
Denne begrensningen ble overvunnet av Java 8-versjonen som tillot grensesnittene å ha standardmetoder. Standardmetodene gir på en måte bakoverkompatibilitet til eksisterende grensesnitt, og vi trenger ikke endre implementeringsklassen. Standardmetodene er også kjent som 'virtuell utvidelsesmetode' eller 'forsvarsmetoder'.
Standardmetoder blir deklarert ved å bruke nøkkelordet 'standard' i erklæringen. Erklæringen følges av definisjonen av metoden. Vi kan overstyre standardmetoden ettersom den er tilgjengelig for klassen som implementerer grensesnittet.
På samme måte kan vi påberope det ved hjelp av implementeringsklasseobjektet fra grensesnittet direkte uten å overstyre 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(); } } Produksjon:
hva er en bin filtype
Ovennevnte Java-program demonstrerer standardmetoden i grensesnittet. Merk i hovedmetoden at vi kan kalle standardmetoden for grensesnittet ved hjelp av klasseobjektet. Dette skyldes at når klassen implementerer grensesnittet, er standardmetoden også tilgjengelig for klassen.
Merk: Vi kunne ha tilsidesatt utskriftsmetoden () også i implementeringsklassen. Merk at hvis overstyrt, endres tilgangsmodifikatoren til standardmetoden til offentlig i implementeringsklassen.
Standardmetoder og flere arv
Det kan oppstå en situasjon i tilfelle flere grensesnitt hvor hvert grensesnitt kan ha en standardmetode med samme prototype. I et slikt tilfelle vet ikke kompilatoren hvilken metode den skal påberope.
Når denne situasjonen oppstår der standardmetoden har samme prototype i alle grensesnittene, er løsningen å overstyre metoden i implementeringsklasse, slik at når implementeringsklasseobjektet kaller standardmetoden, påkaller kompilatoren metoden implementert i klassen .
Følgende Java-program demonstrerer bruken av standardmetoden med flere grensesnitt.
//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(); } }Produksjon:
I programmet ovenfor har vi overstyrt standardmetoden (som har samme prototype i begge grensesnittene) i implementeringsklassen. På denne måten når vi kaller standardmetoden fra hovedmetoden ved hjelp av objektet til implementeringsklassen, blir den overstyrte metoden påkalt.
Java 8 funksjonelle grensesnitt
Et funksjonelt grensesnitt er et grensesnitt som bare har en abstrakt metode. Den kan inneholde et hvilket som helst antall standard- og statiske metoder, men den abstrakte metoden den inneholder er nøyaktig en. I tillegg kan et funksjonelt grensesnitt ha erklæringer om objektklassemetoder.
Funksjonelt grensesnitt er kjent som “ Single Abstract Method Interface ”Eller“ SAM-grensesnitt ”. SAM-grensesnitt er en ny funksjon i Java.
I et Java-program indikeres tilstedeværelsen av et funksjonelt grensesnitt ved hjelp av a @FunctionalInterface kommentar. Når kompilatoren møter denne kommentaren, vet den at grensesnittet som følger denne kommentaren er funksjonelt. Derfor, hvis den inneholder mer enn en abstrakt metode, blinker den en feil.
Kommentaren @FunctionalInterface er imidlertid ikke obligatorisk i Java.
Følgende program demonstrerer det funksjonelle grensesnittet 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!!!'); } } Produksjon:
Det funksjonelle grensesnittet i programmet ovenfor har en enkelt abstrakt metode og har også en erklæring om objektklassemetode som hashCode, toString og er lik. I klassen som implementerer dette grensesnittet, blir den abstrakte metoden overstyrt. I hovedmetoden lager vi et objekt for implementeringsklasse og bruker metoden.
Grensesnitt som Runnable og Comparable er eksempler på funksjonelle grensesnitt gitt i Java. Java 8 lar oss tilordne lambdauttrykk til det funksjonelle grensesnittobjektet.
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(); } } Produksjon:
Java 8 gir også mange innebygde funksjonelle grensesnitt i java.util.function-pakken.
Disse innebygde grensesnittene er beskrevet nedenfor:
# 1) Predikat
Dette er et funksjonelt grensesnitt i Java som har en enkelt abstrakt metodetest. Metoden 'test' returnerer den boolske verdien etter å ha testet det angitte argumentet.
Nedenfor er prototypen for testmetoden til Predicate-grensesnittet.
public interface Predicate { public boolean test(T t); }# 2) BinaryOperator
BinaryOperator-grensesnittet gir en abstrakt metode 'gjelder' som godtar to argumenter og returnerer en resulterende verdi av samme type som argumentene.
Prototypen for akseptmetoden er:
public interface BinaryOperator { public T apply (T x, T y); }# 3) Funksjon
Funksjonsgrensesnittet er et funksjonelt grensesnitt som også har en abstrakt metode kalt ‘bruk’. Denne anvendelsesmetoden tar imidlertid et enkelt argument av typen T og returnerer en verdi av typen R.
Prototypen til applikasjonsmetoden er som følger:
public interface Function { public R apply(T t); }Følgende Java-program demonstrerer ovennevnte innebygde funksjonelle grensesnittpredikat.
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); } } } Produksjon:
Som vi kan se i programmet ovenfor, har vi en liste over strenger. Ved å bruke det funksjonelle grensesnittet Predicate, tester vi om elementet i strengen starter med M, og hvis det gjør det, så skriver det ut navnet.
toppverdenen for warcraft private servere
Klasse Vs-grensesnitt i Java
Selv om klasse og grensesnitt er like siden de har lignende syntaks, har disse to enhetene flere forskjeller enn likheter.
La oss liste opp noen av forskjellene mellom klasse og grensesnitt i Java.
| Klasse | Grensesnitt |
|---|---|
| Vi kan instantiere og lage objekter fra en klasse. | Et grensesnitt kan ikke instantieres. |
| Nøkkelord ‘klasse’ brukes til å lage en klasse. | Grensesnittet opprettes ved hjelp av nøkkelordet ‘interface’. |
| Klasser støtter ikke flere arv i Java. | Grensesnitt støtter flere arv i Java. |
| Klassen inneholder konstruktørene. | Grensesnitt inneholder ikke konstruktører. |
| Klassen kan ikke inneholde abstrakte metoder. | Grensesnitt inneholder bare abstrakte metoder. |
| Klassen kan ha variabler og metoder som er standard, offentlige, private eller beskyttede. | Grensesnittet har bare offentlige variabler og metoder som standard. |
| Det er ikke obligatorisk å knytte modifikatorer som ikke er tilgjengelige, med variabler i klassen. | Grensesnitt kan ha variabler som enten er statiske eller endelige. |
| Vi kan arve en annen klasse fra en klasse. | Vi kan ikke arve en klasse fra grensesnittet. |
| Klassen kan arves ved å bruke nøkkelordet ‘utvider’. | Grensesnittet kan implementeres av en annen klasse ved å bruke nøkkelordet 'implementerer'. Det kan arves av et annet grensesnitt ved hjelp av søkeordet 'utvider'. |
Java utvider Vs-implementeringer
| 'strekker' | ‘Implementerer’ |
|---|---|
| Grensesnitt støtter bare statiske og endelige modifikatorer uten tilgang. | Abstrakt støtter alle ikke-tilgangsmodifikatorer som statisk, endelig, ikke-statisk og ikke-endelig. |
| En klasse bruker 'utvider' søkeord for å arve fra en annen klasse. | Søkeordet 'implementerer' brukes av en klasse for å implementere et grensesnitt. |
| En klasse som arver en annen klasse, kan eller ikke overstyre alle metodene i foreldreklassen. | Klassen som implementerer grensesnittet, må overstyre alle de abstrakte metodene i grensesnittet. |
| Vi kan bare utvide en klasse om gangen ved å bruke søkeordet extends. | Vi kan implementere flere grensesnitt ved å bruke søkeordet 'implementerer'. |
| Et grensesnitt kan utvide et annet grensesnitt ved å bruke søkeordet 'utvider'. | Et grensesnitt kan ikke implementere et annet grensesnitt ved hjelp av 'implementerer' søkeord. |
Kan abstrakt klasse implementeringsgrensesnitt i Java
Ja, en abstrakt klasse kan implementere et grensesnitt ved å bruke nøkkelordet 'implementerer'. Abstraktklassen trenger ikke implementere alle abstrakte grensesnittmetoder. Men generelt er det en god designpraksis å ha et grensesnitt med alle abstrakte metoder, deretter en abstrakt klasse som implementerer dette grensesnittet, og deretter de konkrete klassene.
Nedenfor er et eksempel på en slik implementering i Java.
Her er java.util.List et grensesnitt. Dette grensesnittet er implementert av java.util.AbstractList. Deretter utvides denne AbstractList-klassen med to konkrete klasser, dvs. LinkedList og ArrayList.
Hvis klasser fra LinkedList og ArrayList hadde implementert List-grensesnittet direkte, måtte de implementere alle de abstrakte metodene for List-grensesnitt.
Men i dette tilfellet implementerer klassen AbstractList metodene for List-grensesnitt og overfører dem til LinkedList og ArrayList. Så her får vi fordelen av å erklære type fra grensesnittet og abstrakt klassefleksibilitet ved å implementere den vanlige oppførselen.
Når skal du bruke abstrakt klasse og grensesnitt i Java
Vi bruker hovedsakelig en abstrakt klasse for å definere en standard eller vanlig oppførsel for barneklasser som vil strekke seg fra denne abstrakte klassen. Et grensesnitt brukes til å definere en kontrakt mellom to systemer som samhandler i en applikasjon.
Visse spesifikke situasjoner er ideelle for grensesnitt som skal brukes og visse problemer som bare kan løses ved bruk av abstrakte klasser. I denne delen vil vi diskutere når vi kan bruke grensesnittet og når vi kan bruke abstrakte klasser.
Når skal du bruke et grensesnitt:
- Grensesnitt brukes hovedsakelig når vi har en liten kortfattet funksjonalitet å implementere.
- Når vi implementerer APIer og vi vet at de ikke vil endres på en stund, går vi for grensesnitt den gangen.
- Grensesnitt tillater oss å implementere flere arv. Derfor når vi trenger å implementere flere arv i applikasjonen vår, går vi etter grensesnitt.
- Når vi har et bredt spekter av objekter, er grensesnitt igjen et bedre valg.
- Også når vi må tilby en felles funksjonalitet til mange ikke-relaterte klasser, brukes fortsatt grensesnitt.
Når skal du bruke en abstrakt klasse:
- Abstrakte klasser brukes hovedsakelig når vi trenger å bruke arv i applikasjonen vår.
- Når grensesnitt håndterer offentlige metoder og variabler, bruker vi abstrakte klasser når vi vil bruke modifikatorer for ikke-offentlig tilgang i programmet vårt.
- Hvis nye metoder må legges til, er det bedre å gjøre det i en abstrakt klasse enn i grensesnittet. For hvis vi legger til en ny metode i grensesnittet, endres hele implementeringen ettersom grensesnitt bare har metodeprototyper og klasseimplementering ved bruk av grensesnittet vil gi implementeringen.
- Hvis vi ønsker at forskjellige versjoner av komponentene blir utviklet, går vi for abstrakt klasse. Vi kan lettere endre abstrakte klasser. Men grensesnitt kan ikke endres. Hvis vi vil ha en ny versjon, må vi skrive hele grensesnittet igjen.
- Når vi ønsker å gi en felles implementering for alle komponentene, er abstraktklassen det beste valget.
Grensesnitt mot abstrakt klasse i Java
Nedenfor er noen av forskjellene mellom grensesnitt og abstrakte klasser i Java.
| Grensesnitt | Abstrakt klasse |
|---|---|
| Et grensesnitt er erklært ved å bruke søkeordet 'grensesnitt'. | En abstrakt klasse blir erklært ved hjelp av ‘abstrakt’ nøkkelordet. |
| Grensesnittet kan implementeres ved å bruke nøkkelordet 'implementerer'. | Abstraktet kan arves ved å bruke 'utvider' nøkkelord. |
| Et grensesnitt kan ikke utvide en klasse eller implementere et grensesnitt, det kan bare utvide et annet grensesnitt. | En abstrakt klasse kan utvide en klasse eller implementere flere grensesnitt. |
| Grensesnittmedlemmer kan bare være offentlige. | Abstrakte klassemedlemmer kan være offentlige, private eller beskyttede. |
| Et grensesnitt kan ikke brukes til å gi en implementering. Den kan bare brukes som en erklæring. | En abstrakt klasse kan brukes til å implementere grensesnittet. |
| Flere arv kan oppnås ved hjelp av grensesnitt. | Abstrakt klasse støtter ikke flere arv. |
| Grensesnitt kan bare ha abstrakte metoder. Fra Java 8 kan den ha statiske metoder og standardmetoder. | En abstrakt klasse kan ha en abstrakt eller ikke-abstrakt metode. |
Enum Arv i Java
Vi har diskutert enum datatyper i vår diskusjon om datatyper i Java. Alle enums strekker seg fra java.lang.Enum klasse. Denne klassen java.lang.Enum er en abstrakt klasse.
Også alle enumklasser i Java er 'endelige' som standard. Derfor forsøker å arve en klasse fra enumklasser i en kompilatorfeil.
Siden Java ikke tillater flere arv, kan vi ikke arve enum-klasse fra noen annen klasse, da enum-klasse allerede arver fra java.lang.Enum. Imidlertid kan enumklasser implementere grensesnitt i Java, og dette kalles 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 } }Produksjon:
Her har vi et grensesnitt WeekDays med en abstrakt metode prototype displaydays (). Deretter definerer vi en enum class Days som implementerer WeekDays interface. Her definerer vi enumverdier fra SUNDAY til LATURDAY og overstyrer også displaydays-metoden.
Til slutt, i hovedmetoden, får vi tilgang til enumverdien og viser den.
ofte stilte spørsmål
Q # 1) Hva skjer hvis du gir en metodekropp i grensesnittet?
Svar: For Java-versjoner før Java 8 er ikke metodens kropp tillatt i grensesnittet. Men siden Java 8 kan vi enten definere en standard eller statiske metoder inne i grensesnittet.
Q # 2) Kan et grensesnitt ha variabler i Java 8?
Svar: Vi kan ha konstante variabler i Java 8 ved hjelp av statiske og endelige modifikatorer. Men vi kan ikke ha forekomstvariabler i Java-grensesnitt. Ethvert forsøk på å erklære forekomstvariabler i et grensesnitt vil resultere i en kompilatorfeil.
Q # 3) Hva er forbedringene i grensesnitt i Java 8?
Svar: Den viktigste forbedringen for grensesnitt i Java 8 er at statiske metoder og standardmetoder er tillatt i grensesnitt. Vi kan få metoder erklært som statiske eller standard og definere dem inne i grensesnittet.
Q # 4) Kan vi overstyre standardmetoden i Java-grensesnittet?
Svar: Nei. Det er ikke obligatorisk å overstyre standardmetoden i grensesnittet. Dette er fordi når vi implementerer et grensesnitt i en klasse, er standardmetoden for klassen tilgjengelig for implementeringsklassen. Derfor bruker vi objektet til implementeringsklassen, kan vi få tilgang til standardmetoden for grensesnittet.
Q # 5) Kan grensesnitt ha felt i Java?
hva er en .swf fil
Svar: Ja, vi kan ha felt eller variabler i grensesnitt i Java, men som standard er alle disse feltene statiske, endelige og offentlige.
Konklusjon
I denne veiledningen har vi diskutert endringene som ble gjort i grensesnitt i Java 8. Java 8 introduserte statiske og standardmetoder i grensesnitt. Tidligere kunne vi bare ha abstrakte metoder i grensesnittet. Men fra Java 8 og utover kan vi definere standard og statiske metoder i Java.
Java 8 tillater også bruk av lambda-uttrykk med de funksjonelle grensesnittene i Java. Så diskuterte vi også abstrakte klasser og grensesnitt og så når vi skulle bruke hver av dem i Java. Vi har også sett enum-arven i Java.
Vi diskuterte også noen av forskjellene mellom utvidelser og redskaper, klasse og grensesnitt, abstrakt klasse og grensesnitt, etc.
=> Sjekk ALLE Java-opplæringsprogrammer her.
Anbefalt lesing
- Java-grensesnitt og abstrakt klasseopplæring med eksempler
- Sammenlignbare og komparatorgrensesnitt i Java
- ListIterator-grensesnitt i Java med eksempler
- Sett grensesnitt i Java: Java Set Tutorial med eksempler
- Markergrensesnitt i Java: Serialiserbart og klonabelt
- Java strenglengde () Metode med eksempler
- Java-distribusjon: Opprettelse og utføring av Java JAR-fil
- Hvordan bruke Java toString-metoden?