interface enhancements java 8 java functional interface
Aquest tutorial explica les addicions a la interfície a Java 8 i les diferències entre conceptes Java com una classe abstracta, amplia paraules clau, etc. amb les interfícies:
Hem explorat tot Interfícies a Java al nostre últim tutorial. Hem introduït i tractat els conceptes bàsics d’interfícies a Java, incloses les múltiples interfícies.
Abans de Java 8, es permetia a les interfícies que només tinguessin mètodes abstractes i variables estàtiques i finals. Els mètodes abstractes són públics per defecte i han de ser substituïts per la classe que implementa una interfície.
Per tant, la interfície era principalment un contracte i només estava relacionada amb mètodes constants (estàtics i finals) i abstractes.
=> Feu una ullada a la guia per a principiants de Java aquí.
Què aprendreu:
- Canvis d'interfícies a Java 8
- Interfícies funcionals de Java 8
- Interfície de classe Vs a Java
- Java amplia les implementacions
- Interfície Vs Classe Resum En Java
- Conclusió
Canvis d'interfícies a Java 8
La versió de Java 8 introdueix o ens permet tenir mètodes estàtics i predeterminats a les interfícies. Utilitzant mètodes predeterminats en una interfície, els desenvolupadors poden afegir més mètodes a les interfícies. D'aquesta manera no molesten ni canvien les classes que implementen la interfície.
Java 8 també permet que la interfície tingui un mètode estàtic. Els mètodes estàtics són els mateixos que definim a les classes. Tingueu en compte que la classe que implementa la interfície no pot substituir el mètode estàtic.
La introducció de mètodes estàtics i predeterminats a la interfície va facilitar la modificació de les interfícies sense problemes i va facilitar la implementació de les interfícies.
Java 8 també introdueix 'Lambda Expressions' a les interfícies funcionals. A més, a partir de Java 8 hi ha més interfícies funcionals incorporades a Java.
En aquest tutorial, analitzarem totes aquestes addicions a les interfícies de Java 8 i també discutirem algunes de les diferències entre diversos conceptes de Java, com ara classes abstractes, estén paraules clau, etc. amb les interfícies.
Mètode estàtic en interfície a Java
Les interfícies també poden tenir mètodes que poden tenir definicions. Aquests són els mètodes estàtics de la interfície. Els mètodes estàtics es defineixen dins de la interfície i no poden ser anul·lats ni canviats per les classes que implementen aquesta interfície.
Podem anomenar aquests mètodes estàtics utilitzant directament el nom de la interfície.
L'exemple següent mostra l'ús del mètode estàtic.
//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 ()'); } } Sortida:
El programa anterior té una interfície de prova. Té un mètode estàtic anomenat ‘static_print’ i també un mètode no estàtic anomenat mètode no estàtic.
Hem implementat la TestInterface a TestClass i hem anul·lat el mètode nonStatic. A continuació, al mètode principal, anomenem mètode static_print directament mitjançant TestInterface i nonStaticMethod mitjançant l’objecte de TestClass.
Mètode per defecte de la interfície
Com ja s'ha esmentat, les interfícies anteriors a Java 8 només permetien mètodes abstractes. A continuació, proporcionaríem aquesta implementació del mètode en una classe independent. Si haguéssim d’afegir un nou mètode a la interfície, hauríem de proporcionar el seu codi d’implementació a la mateixa classe.
Per tant, si alteréssim la interfície afegint-hi un mètode, la classe d'implementació també canviaria.
Aquesta limitació va ser superada per la versió de Java 8 que permetia que les interfícies tinguessin mètodes predeterminats. Els mètodes predeterminats proporcionen una certa compatibilitat amb les interfícies existents i no hem d’alterar la classe d’implementació. Els mètodes predeterminats també es coneixen com a 'mètode d'extensió virtual' o 'mètode defensor'.
Els mètodes predeterminats es declaren utilitzant la paraula clau 'predeterminada' a la declaració. La declaració va seguida de la definició del mètode. Podem substituir el mètode per defecte, ja que està disponible per a la classe que implementa la interfície.
De la mateixa manera, podem invocar-lo utilitzant directament l’objecte de la classe d’implementació sense substituir-lo.
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(); } } Sortida:
dfs i bfs c ++
El programa Java anterior mostra el mètode per defecte a la interfície. Al mètode principal, tingueu en compte que podem anomenar el mètode per defecte de la interfície mitjançant l'objecte class. Això es deu al fet que a mesura que la classe implementa la interfície, el mètode per defecte també està disponible per a la classe.
Nota: Podríem haver anul·lat el mètode print () també a la classe d'implementació. Tingueu en compte que si s’anul·la, el modificador d’accés del mètode per defecte canviarà a públic a la classe d’implementació.
Mètodes per defecte i herència múltiple
Pot sorgir una situació en cas de múltiples interfícies en què cada interfície pugui tenir un mètode per defecte amb el mateix prototip. En aquest cas, el compilador no sap quin mètode invocar.
Quan es produeix aquesta situació en què el mètode per defecte té el mateix prototip a totes les interfícies, la solució consisteix a substituir el mètode a la classe d'implementació de manera que quan l'objecte de classe d'implementació crida al mètode per defecte, el compilador invoca el mètode implementat a la classe .
El següent programa Java mostra l’ús del mètode per defecte amb diverses interfícies.
//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(); } }Sortida:
Preguntes sobre l'entrevista c c ++
Al programa anterior, hem substituït el mètode per defecte (que té el mateix prototip a les dues interfícies) a la classe d'implementació. D'aquesta manera, quan anomenem el mètode per defecte des del mètode principal que utilitza l'objecte de la classe d'implementació, s'invoca el mètode anul·lat.
Interfícies funcionals de Java 8
Una interfície funcional és una interfície que només té un mètode abstracte. Pot contenir qualsevol nombre de mètodes estàtics i predeterminats, però el mètode abstracte que conté és exactament un. A més, una interfície funcional pot contenir declaracions de mètodes de classe d'objectes.
La interfície funcional es coneix com ' Interfície de mètode abstracte únic 'O' Interfície SAM ”. La interfície SAM és una nova característica de Java.
En un programa Java, la presència d’una interfície funcional s’indica mitjançant un @FuncionalInterface anotació. Quan el compilador troba aquesta anotació, sap que la interfície que segueix aquesta anotació és funcional. Per tant, si conté més d’un mètode abstracte, apareix un error.
L’anotació @FuncionalInterface no obstant això, no és obligatori a Java.
El programa següent mostra la interfície funcional a 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!!!'); } } Sortida:
La interfície funcional del programa anterior té un únic mètode abstracte i també té una declaració de mètode de classe d'objectes com hashCode, toString i igual. A la classe que implementa aquesta interfície, el mètode abstracte és anul·lat. Al mètode principal, creem un objecte de classe d'implementació i fem servir el mètode.
Les interfícies com Runnable i Comparable són exemples d’interfícies funcionals proporcionades a Java. Java 8 ens permet assignar expressions lambda a l'objecte d'interfície funcional.
El següent exemple de programa ho demostra.
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(); } } Sortida:
Java 8 també proporciona moltes interfícies funcionals integrades al paquet java.util.function.
Aquestes interfícies integrades es descriuen a continuació:
# 1) Predicat
Es tracta d’una interfície funcional a Java que té una única prova de mètode abstracte. El mètode 'test' retorna el valor booleà després de provar l'argument especificat.
A continuació es mostra el prototipus per al mètode de prova de la interfície Predicat.
public interface Predicate { public boolean test(T t); }# 2) BinaryOperator
La interfície de BinaryOperator proporciona un mètode abstracte 'aplicar' que accepta dos arguments i retorna un valor resultant del mateix tipus que els arguments.
El prototip del mètode accept és:
public interface BinaryOperator { public T apply (T x, T y); }# 3) Funció
La interfície de funció és una interfície funcional que també té un mètode abstracte anomenat 'aplicar'. Aquest mètode d’aplicació, però, pren un únic argument de tipus T i retorna un valor de tipus R.
El prototip del mètode d’aplicació és el següent:
public interface Function { public R apply(T t); }El programa Java següent mostra el predicat interfície funcional incorporada anteriorment.
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); } } } Sortida:
Com podem veure al programa anterior, tenim una llista de cadenes. Mitjançant la interfície funcional Predicat, comprovem si l’element de la cadena comença per M i, si ho fa, imprimeix el nom.
Interfície de classe Vs a Java
Tot i que la classe i la interfície són similars, ja que tenen una sintaxi similar, aquestes dues entitats tenen més diferències que similituds.
Anomenem algunes de les diferències entre classe i interfície a Java.
| Classe | Interfície |
|---|---|
| Podem crear instàncies i crear objectes a partir d’una classe. | No es pot crear una interfície. |
| La paraula clau 'classe' s'utilitza per crear una classe. | La interfície es crea amb la paraula clau 'interfície'. |
| Les classes no admeten l'herència múltiple a Java. | Les interfícies admeten herències múltiples a Java. |
| La classe conté els constructors. | Les interfícies no contenen constructors. |
| La classe no pot contenir mètodes abstractes. | Les interfícies només contenen mètodes abstractes. |
| La classe pot tenir variables i mètodes predeterminats, públics, privats o protegits. | La interfície només té variables i mètodes públics per defecte. |
| No és obligatori associar modificadors sense accés a variables de la classe. | Les interfícies poden tenir variables estàtiques o finals. |
| Podem heretar una altra classe d’una classe. | No podem heretar una classe de la interfície. |
| La classe es pot heretar mitjançant la paraula clau 'extends'. | La interfície la pot implementar una altra classe mitjançant la paraula clau 'implements'. Pot ser heretat per una altra interfície mitjançant la paraula clau 'extends'. |
Java amplia les implementacions
| 'S'estén' | 'Eines' |
|---|---|
| Les interfícies només admeten modificadors estàtics i finals de no accés. | Resum admet tots els modificadors sense accés, com estàtic, final, no estàtic i no final. |
| Una classe utilitza la paraula clau 'extends' per heretar d'una altra classe. | La paraula clau 'implements' la fa servir una classe per implementar una interfície. |
| Una classe que hereta una altra classe pot anul·lar o no tots els mètodes de la classe pare. | La classe que implementa la interfície ha de substituir tots els mètodes abstractes de la interfície. |
| Només podem ampliar una classe a la vegada amb la paraula clau extends. | Podem implementar diverses interfícies mitjançant la paraula clau 'implementos'. |
| Una interfície pot ampliar una altra interfície mitjançant la paraula clau 'extends'. | Una interfície no pot implementar una altra interfície mitjançant paraules clau 'implementa'. |
Can Abstract Class implementa la interfície a Java
Sí, una classe abstracta pot implementar una interfície mitjançant la paraula clau 'implements'. La classe abstracta no necessita implementar tots els mètodes abstractes de la interfície. Però, en general, és una bona pràctica de disseny tenir una interfície amb tots els mètodes abstractes, després una classe abstracta que implementi aquesta interfície i després les classes concretes.
A continuació es mostra un exemple d'aquesta implementació a Java.
Aquí java.util.List és una interfície. Aquesta interfície està implementada per java.util.AbstractList. Llavors, aquesta classe AbstractList s’estén per dues classes concretes, és a dir, LinkedList i ArrayList.
Si les classes LinkedList i ArrayList haguessin implementat la interfície List directament, haurien d'implementar tots els mètodes abstractes de la interfície List.
Però en aquest cas, la classe AbstractList implementa els mètodes de la interfície List i els transmet a LinkedList i ArrayList. Així doncs, aquí obtenim l'avantatge de declarar tipus a partir de la interfície i la flexibilitat abstracta de la classe d'implementar el comportament comú.
Quan s'utilitza la classe i la interfície abstractes a Java
Utilitzem principalment una classe abstracta per definir un comportament predeterminat o comú de les classes fill que s’estendrà a partir d’aquesta classe abstracta. Una interfície s'utilitza per definir un contracte entre dos sistemes que interactuen en una aplicació.
Algunes situacions específiques són ideals per utilitzar interfícies i certs problemes que només es poden resoldre mitjançant classes abstractes. En aquesta secció, analitzarem quan podem utilitzar la interfície i quan podem utilitzar classes abstractes.
Quan s'utilitza una interfície:
- Les interfícies s’utilitzen principalment quan tenim una petita funcionalitat concisa a implementar.
- Quan estem implementant API i sabem que no canviaran durant un temps, llavors ens dediquem a les interfícies.
- Les interfícies ens permeten implementar múltiples herències. Per tant, quan hem d’implementar múltiples herències a la nostra aplicació, apostem per les interfícies.
- Quan tenim una àmplia gamma d'objectes, de nou les interfícies són una millor opció.
- També quan hem de proporcionar una funcionalitat comuna a moltes classes no relacionades, encara s’utilitzen interfícies.
Quan s'utilitza una classe abstracta:
- Les classes abstractes s’utilitzen principalment quan hem d’utilitzar l’herència a la nostra aplicació.
- Com que les interfícies tracten mètodes i variables públiques, sempre que volem utilitzar modificadors d’accés no públics al nostre programa, fem servir classes abstractes.
- Si s’han d’afegir nous mètodes, és millor fer-ho en una classe abstracta que en una interfície. Perquè si afegim un nou mètode a la interfície, tota la implementació canvia ja que les interfícies només tenen prototips de mètode i la implementació de classe que utilitza la interfície proporcionarà la implementació.
- Si volem que es desenvolupin diferents versions dels components, anem a la classe abstracta. Podem canviar les classes abstractes més fàcilment. Però les interfícies no es poden canviar. Si volem una nova versió, hem de tornar a escriure tota la interfície.
- Quan volem proporcionar una implementació comuna per a tots els components, llavors la classe abstracta és la millor opció.
Interfície Vs Classe Resum En Java
A continuació es detallen algunes de les diferències entre les classes Interfaces i Abstract en Java.
| Interfície | Classe abstracta |
|---|---|
| Es declara una interfície mitjançant la paraula clau 'interfície'. | Es declara una classe abstracta mitjançant la paraula clau 'abstract'. |
| La interfície es pot implementar mitjançant la paraula clau 'implementos'. | El resum es pot heretar mitjançant la paraula clau 'extends'. |
| Una interfície no pot ampliar una classe ni implementar una interfície, només pot ampliar una altra interfície. | Una classe abstracta pot ampliar una classe o implementar diverses interfícies. |
| Els membres de la interfície només poden ser públics. | Els membres de la classe abstracta poden ser públics, privats o protegits. |
| No es pot utilitzar una interfície per proporcionar una implementació. Només es pot utilitzar com a declaració. | Es pot utilitzar una classe abstracta per implementar la interfície. |
| Es pot aconseguir una herència múltiple mitjançant interfícies. | La classe abstracta no admet herències múltiples. |
| Les interfícies només poden tenir mètodes abstractes. Des de Java 8, pot tenir mètodes estàtics i predeterminats. | Una classe abstracta pot tenir un mètode abstracte o no abstracte. |
Herència Enum a Java
Hem discutit els tipus de dades enum a la nostra discussió sobre els tipus de dades a Java. Totes les enumeracions van des de la classe java.lang.Enum. Aquesta classe java.lang.Enum és una classe abstracta.
A més, totes les classes d’enum a Java són ‘finals’ per defecte. Per tant, un intent d’heretar una classe de qualsevol classe enum resulta en un error del compilador.
Com que Java no permet l’herència múltiple, no podem heretar la classe enum de cap altra classe, ja que la classe enum ja hereta de java.lang.Enum. No obstant això, les classes enum poden implementar interfícies a Java i això s'anomena herència Enum a Java.
A continuació es mostra un exemple d’herència Enum a 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 } }Sortida:
Aquí tenim una interfície WeekDays amb un prototip de mètode abstracte displaydays (). A continuació, definim una classe enum Days que implementa la interfície WeekDays. Aquí definim els valors enumerals de DIUMENGE a DISSABTE i també substituïm el mètode displaydays.
Finalment, en el mètode principal, accedim al valor enum i el mostrem.
Preguntes freqüents
P # 1) Què passa si assigneu un cos de mètode a la interfície?
Resposta: Per a versions de Java anteriors a Java 8, el cos del mètode no està permès a la interfície. Però des de Java 8, podem definir mètodes estàtics o per defecte dins de la interfície.
Q # 2) Una interfície pot tenir variables a Java 8?
Resposta: Podem tenir variables constants a Java 8 mitjançant modificadors estàtics i finals. Però no podem tenir variables d’instància a les interfícies Java. Qualsevol intent de declarar variables d’instància en una interfície donarà lloc a un error del compilador.
P # 3) Quines són les millores en les interfícies de Java 8?
Resposta: La millora més important per a les interfícies de Java 8 és que es permeten mètodes estàtics i predeterminats a les interfícies. Podem tenir mètodes declarats com estàtics o predeterminats i definir-los dins de la interfície.
Q # 4) Podem anul·lar el mètode per defecte a la interfície Java?
Resposta: No, no és obligatori substituir el mètode per defecte a la interfície. Això es deu al fet que quan implementem una interfície en una classe, el mètode per defecte de la classe és accessible per a la classe d'implementació. Per tant, mitjançant l’objecte de la classe d’implementació, podem accedir al mètode per defecte de la interfície.
P # 5) Les interfícies poden tenir camps a Java?
millor lloc per veure animis gratuïts
Resposta: Sí, podem tenir camps o variables en interfícies a Java, però per defecte tots aquests camps són estàtics, finals i públics.
Conclusió
En aquest tutorial, hem comentat els canvis fets a les interfícies a Java 8. Java 8 va introduir mètodes estàtics i predeterminats a les interfícies. Abans només podíem tenir mètodes abstractes a la interfície. Però, a partir de Java 8, podem definir mètodes estàtics i per defecte a Java.
A més, Java 8 permet utilitzar expressions lambda amb les interfícies funcionals de Java. Després també vam parlar de classes i interfícies abstractes i vam veure quan s’utilitzava cadascuna d’elles a Java. També hem vist l’herència enum a Java.
També vam discutir algunes de les diferències entre extensions i implementacions, classe i interfície, classe abstracta i interfície, etc.
=> Consulteu TOTS els tutorials de Java aquí.
Lectura recomanada
- Interfície Java i tutoria de classes abstractes amb exemples
- Interfícies comparables i comparadores a Java
- Interfície ListIterator a Java amb exemples
- Configuració de la interfície a Java: Tutorial de configuració de Java amb exemples
- Interfície de marcador a Java: serialitzable i clonable
- Java String length () Mètode amb exemples
- Desplegament de Java: creació i execució del fitxer JAR de Java
- Com s'utilitza el mètode Java toString?