interface enhancements java 8 java functional interface
Acest tutorial explică adăugările la interfața din Java 8 și diferențele dintre conceptele Java, cum ar fi o clasă abstractă, extinde cuvântul cheie etc. cu interfețele:
Am explorat totul Interfețe în Java în ultimul nostru tutorial. Am introdus și acoperit conceptele de bază ale interfețelor în Java, inclusiv interfețele multiple.
Înainte de Java 8, interfețelor li se permitea să aibă doar metode abstracte și variabile statice și finale. Metodele abstracte sunt publice în mod implicit și trebuie înlocuite de clasa care implementează o interfață.
Deci, interfața a fost în principal un contract și a fost implicată doar cu constante (statice și finale) și metode abstracte.
=> Consultați aici Ghidul pentru începători Java.
Ce veți învăța:
- Modificări de interfețe în Java 8
- Interfețe funcționale Java 8
- Interfață de clasă V în Java
- Java Extinde Vs Implementări
- Interfață Vs clasă abstractă în Java
- Concluzie
Modificări de interfețe în Java 8
Versiunea Java 8 introduce sau ne permite să avem metode statice și implicite în interfețe. Folosind metode implicite într-o interfață, dezvoltatorii pot adăuga mai multe metode la interfețe. În acest fel, ele nu deranjează și nu modifică clasele care implementează interfața.
Java 8 permite, de asemenea, interfeței să aibă o metodă statică. Metodele statice sunt aceleași cu cele pe care le definim în clase. Rețineți că metoda statică nu poate fi ignorată de clasa care implementează interfața.
Introducerea metodelor statice și implicite în interfață a facilitat modificarea interfețelor fără probleme și, de asemenea, a facilitat implementarea interfețelor.
Java 8 introduce, de asemenea, „Expresii Lambda” în interfețele funcționale. În plus, de la Java 8 și mai departe există mai multe interfețe funcționale încorporate adăugate în Java.
În acest tutorial, vom discuta toate aceste adăugiri la interfețele din Java 8 și vom discuta, de asemenea, unele dintre diferențele dintre diferite concepte Java, cum ar fi clasele abstracte, extinde cuvintele cheie etc. cu interfețele.
Metodă statică în interfață în Java
Interfețele pot avea și metode care pot avea definiții. Acestea sunt metodele statice din interfață. Metodele statice sunt definite în interiorul interfeței și nu pot fi suprascrise sau modificate de clasele care implementează această interfață.
Putem numi aceste metode statice folosind direct numele interfeței.
Următorul exemplu demonstrează utilizarea metodei statice.
//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 ()'); } } Ieșire:
Programul de mai sus are un TestInterface. Are o metodă statică numită „static_print” și, de asemenea, o metodă nestatică numită metoda nestatică.
Am implementat TestInterface în TestClass și am ignorat metoda nonStatic. Apoi, în metoda principală, numim metoda static_print direct folosind TestInterface și nonStaticMethod folosind obiectul TestClass.
Metoda implicită a interfeței
După cum sa menționat deja, interfețele înainte de Java 8 permiteau doar metode abstracte. Apoi am furniza această metodă de implementare într-o clasă separată. Dacă ar trebui să adăugăm o nouă metodă la interfață, atunci trebuie să furnizăm codul de implementare al acesteia în aceeași clasă.
Prin urmare, dacă am modifica interfața prin adăugarea unei metode la aceasta, și clasa de implementare s-ar schimba.
Această limitare a fost depășită de versiunea Java 8 care a permis interfețelor să aibă metode implicite. Metodele implicite asigură într-un fel compatibilitatea înapoi cu interfețele existente și nu trebuie să modificăm clasa de implementare. Metodele implicite sunt cunoscute și sub denumirea de „metodă de extensie virtuală” sau „metode de apărare”.
Metodele implicite sunt declarate utilizând cuvântul cheie „implicit” în declarație. Declarația este urmată de definiția metodei. Putem suprascrie metoda implicită, deoarece este disponibilă pentru clasa care implementează interfața.
În același mod, îl putem invoca folosind obiectul clasei de implementare din interfață direct, fără a-l suprascrie.
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(); } } Ieșire:
software de parolă pentru Windows 7
Programul Java de mai sus demonstrează metoda implicită în interfață. În metoda principală, rețineți că putem apela metoda implicită a interfeței folosind obiectul clasei. Acest lucru se întâmplă deoarece clasa implementează interfața, metoda implicită este disponibilă și pentru clasă.
Notă: Am fi putut suprascrie metoda print () și în clasa de implementare. Rețineți că, dacă este suprascris, modificatorul de acces al metodei implicite se va schimba în public în clasa de implementare.
Metode implicite și moștenire multiplă
S-ar putea să apară o situație în cazul mai multor interfețe în care fiecare interfață ar putea avea o metodă implicită cu același prototip. Într-un astfel de caz, compilatorul nu știe ce metodă să invoce.
Când apare această situație în care metoda implicită are același prototip în toate interfețele, atunci soluția este de a suprascrie metoda în clasa de implementare astfel încât atunci când obiectul clasei de implementare apelează metoda implicită, compilatorul invocă metoda implementată în clasă .
Următorul program Java demonstrează utilizarea metodei implicite cu mai multe interfețe.
//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(); } }Ieșire:
În programul de mai sus, am înlocuit metoda implicită (care are același prototip în ambele interfețe) în clasa de implementare. În acest fel, când apelăm metoda implicită din metoda principală folosind obiectul clasei de implementare, se invocă metoda suprascrisă.
Interfețe funcționale Java 8
O interfață funcțională este o interfață care are o singură metodă abstractă. Poate conține orice număr de metode implicite și statice, dar metoda abstractă pe care o conține este exact una. În plus, o interfață funcțională poate avea declarații de metode de clasă de obiecte.
Interfața funcțională este cunoscută sub numele de „ Interfață cu metodă abstractă unică ”Sau„ Interfață SAM ”. Interfața SAM este o caracteristică nouă în Java.
Într-un program Java, prezența unei interfețe funcționale este indicată prin utilizarea unui @FunctionalInterface adnotare. Când compilatorul întâlnește această adnotare, atunci știe că interfața care urmărește această adnotare este funcțională. Prin urmare, dacă conține mai multe metode abstracte, atunci clipește o eroare.
Adnotarea @FunctionalInterface cu toate acestea, nu este obligatoriu în Java.
Următorul program demonstrează interfața funcțională în 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!!!'); } } Ieșire:
Interfața funcțională din programul de mai sus are o singură metodă abstractă și are, de asemenea, o declarație de metodă de clasă de obiect, cum ar fi hashCode, toString și egal. În clasa care implementează această interfață, metoda abstractă este anulată. În metoda principală, creăm un obiect al clasei de implementare și folosim metoda.
Interfețele precum Runnable și Comparable sunt exemple de interfețe funcționale furnizate în Java. Java 8 ne permite să atribuim expresii lambda obiectului interfeței funcționale.
Următorul exemplu de program demonstrează acest lucru.
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(); } } Ieșire:
Java 8 oferă, de asemenea, multe interfețe funcționale încorporate în pachetul java.util.function.
Aceste interfețe încorporate sunt descrise mai jos:
# 1) Predicat
Aceasta este o interfață funcțională în Java care are un singur test de metodă abstractă. Metoda „test” returnează valoarea booleană după testarea argumentului specificat.
Mai jos este prezentat prototipul pentru metoda de testare a interfeței Predicate.
public interface Predicate { public boolean test(T t); }# 2) BinaryOperator
Interfața BinaryOperator oferă o metodă abstractă „se aplică” care acceptă două argumente și returnează o valoare rezultată de același tip ca argumentele.
Prototipul pentru metoda de acceptare este:
public interface BinaryOperator { public T apply (T x, T y); }# 3) Funcția
Interfața funcțională este o interfață funcțională care are și o metodă abstractă numită „aplicați”. Cu toate acestea, această metodă de aplicare ia un singur argument de tip T și returnează o valoare de tip R.
Prototipul metodei de aplicare este după cum urmează:
public interface Function { public R apply(T t); }Următorul program Java demonstrează predicatul de interfață funcțională încorporat de mai sus.
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); } } } Ieșire:
cel mai bun site pentru a viziona anime dublat
După cum putem vedea în programul de mai sus, avem o listă de șiruri. Folosind interfața funcțională Predicate, testăm dacă elementul din șir începe cu M și dacă da, apoi imprimă numele.
Interfață de clasă V în Java
Deși clasa și interfața sunt similare, deoarece au o sintaxă similară, aceste două entități au mai multe diferențe decât asemănări.
Să enumerăm câteva dintre diferențele dintre clasă și interfață în Java.
| Clasă | Interfață |
|---|---|
| Putem instanția și crea obiecte dintr-o clasă. | O interfață nu poate fi instanțiată. |
| Cuvântul cheie „clasă” este utilizat pentru a crea o clasă. | Interfața este creată utilizând cuvântul cheie „interfață”. |
| Clasele nu acceptă moștenirea multiplă în Java. | Interfețele acceptă moștenirea multiplă în Java. |
| Clasa conține constructorii. | Interfețele nu conțin constructori. |
| Clasa nu poate conține metode abstracte. | Interfețele conțin doar metode abstracte. |
| Clasa poate avea variabile și metode care sunt implicite, publice, private sau protejate. | Interfața are numai variabile și metode publice în mod implicit. |
| Nu este obligatoriu să asociați modificatorii fără acces cu variabilele clasei. | Interfețele pot avea variabile fie statice, fie finale. |
| Putem moșteni o altă clasă dintr-o clasă. | Nu putem moșteni o clasă din interfață. |
| Clasa poate fi moștenită folosind cuvântul cheie „extinde”. | Interfața poate fi implementată de o altă clasă folosind cuvântul cheie „implemente”. Poate fi moștenit de o altă interfață folosind cuvântul cheie „extends”. |
Java Extinde Vs Implementări
| „Extinde” | „Unelte” |
|---|---|
| Interfețele acceptă doar modificatori statici și finali fără acces. | Abstract acceptă toți modificatorii fără acces, cum ar fi static, final, nestatic și non-final. |
| O clasă folosește cuvântul cheie „extends” pentru a moșteni de la o altă clasă. | Cuvântul cheie „implementează” este folosit de o clasă pentru a implementa o interfață. |
| O clasă care moștenește o altă clasă poate sau nu poate suprascrie toate metodele clasei părinte. | Clasa care implementează interfața trebuie să anuleze toate metodele abstracte ale interfeței. |
| Putem extinde o singură clasă odată folosind cuvântul cheie extends. | Putem implementa mai multe interfețe folosind cuvântul cheie „implementare”. |
| O interfață poate extinde o altă interfață utilizând cuvântul cheie „extends”. | O interfață nu poate implementa o altă interfață folosind cuvinte cheie „implementează”. |
Poate Abstract Class implementa interfața în Java
Da, o clasă abstractă poate implementa o interfață folosind cuvântul cheie „implemente”. Clasa abstractă nu trebuie să implementeze toate metodele abstracte ale interfeței. Dar, în general, este o bună practică de proiectare să ai o interfață cu toate metodele abstracte, apoi o clasă abstractă care implementează această interfață și apoi clasele concrete.
Dat mai jos este un exemplu de astfel de implementare în Java.
Aici java.util.List este o interfață. Această interfață este implementată de java.util.AbstractList. Apoi, această clasă AbstractList este extinsă cu două clase concrete, adică LinkedList și ArrayList.
Dacă clasele LinkedList și ArrayList ar fi implementat direct interfața List, atunci ar trebui să implementeze toate metodele abstracte ale interfeței List.
Dar, în acest caz, clasa AbstractList implementează metodele interfeței List și le transmite la LinkedList și ArrayList. Deci, aici avem avantajul de a declara tipul din interfață și flexibilitatea abstractă a clasei de a implementa comportamentul comun.
Când se folosește clasa abstractă și interfața în Java
Folosim în principal o clasă abstractă pentru a defini un comportament implicit sau comun al claselor copil care se vor extinde din această clasă abstractă. O interfață este utilizată pentru a defini un contract între două sisteme care interacționează într-o aplicație.
Anumite situații specifice sunt ideale pentru utilizarea interfețelor și anumite probleme care pot fi rezolvate numai folosind clase abstracte. În această secțiune, vom discuta când putem folosi interfața și când putem folosi clase abstracte.
Când utilizați o interfață:
- Interfețele sunt utilizate în principal atunci când avem o funcționalitate concisă mică de implementat.
- Când implementăm API-uri și știm că nu se vor schimba pentru o vreme, atunci ne îndreptăm spre interfețe.
- Interfețele ne permit să implementăm moștenirea multiplă. Prin urmare, atunci când trebuie să implementăm moștenirea multiplă în aplicația noastră, mergem pentru interfețe.
- Când avem o gamă largă de obiecte, din nou interfețele sunt o alegere mai bună.
- De asemenea, atunci când trebuie să oferim o funcționalitate comună multor clase fără legătură, sunt folosite încă interfețe.
Când utilizați o clasă abstractă:
- Clasele abstracte sunt utilizate în principal atunci când trebuie să folosim moștenirea în aplicația noastră.
- Deoarece interfețele se ocupă de metode și variabile publice, ori de câte ori dorim să utilizăm modificatori de acces non-public în programul nostru, folosim clase abstracte.
- Dacă trebuie adăugate noi metode, atunci este mai bine să o faceți într-o clasă abstractă decât în interfață. Deoarece dacă adăugăm o nouă metodă în interfață, întreaga implementare se modifică, deoarece interfețele au doar prototipuri de metodă, iar implementarea clasei care utilizează interfața va asigura implementarea.
- Dacă dorim să se dezvolte diferite versiuni ale componentelor, atunci mergem la clasa abstractă. Putem schimba clasele abstracte mai ușor. Dar interfețele nu pot fi schimbate. Dacă dorim o nouă versiune, atunci trebuie să scriem din nou întreaga interfață.
- Când vrem să oferim o implementare comună pentru toate componentele, atunci clasa abstractă este cea mai bună alegere.
Interfață Vs clasă abstractă în Java
Prezentate mai jos sunt câteva dintre diferențele dintre clasele Interfaces și Abstract din Java.
| Interfață | Clasa abstractă |
|---|---|
| O interfață este declarată folosind cuvântul cheie „interfață”. | O clasă abstractă este declarată folosind cuvântul cheie „abstract”. |
| Interfața poate fi implementată utilizând cuvântul cheie „implementează”. | Rezumatul poate fi moștenit folosind cuvântul cheie „extends”. |
| O interfață nu poate extinde o clasă sau implementa o interfață, poate extinde doar o altă interfață. | O clasă abstractă poate extinde o clasă sau poate implementa mai multe interfețe. |
| Membrii interfeței pot fi publici numai. | Membrii clasei rezumate pot fi publici, privați sau protejați. |
| O interfață nu poate fi utilizată pentru a furniza o implementare. Poate fi folosit doar ca declarație. | O clasă abstractă poate fi utilizată pentru implementarea interfeței. |
| Moștenirea multiplă poate fi realizată folosind interfețe. | Clasa abstractă nu acceptă moștenirea multiplă. |
| Interfețele pot avea doar metode abstracte. De la Java 8, poate avea metode statice și implicite. | O clasă abstractă poate avea o metodă abstractă sau non-abstractă. |
Moștenirea Enum în Java
Am discutat despre tipurile de date enum în discuția noastră despre tipurile de date în Java. Toate enumerările se extind din clasa java.lang.Enum. Această clasă java.lang.Enum este o clasă abstractă.
De asemenea, toate clasele enum din Java sunt „finale” în mod implicit. Prin urmare, o încercare de a moșteni o clasă din orice clasă enum are ca rezultat o eroare a compilatorului.
Deoarece Java nu permite moștenirea multiplă, nu putem moșteni clasa enum de la nicio altă clasă, deoarece clasa enum moștenește deja de la java.lang.Enum. Cu toate acestea, clasele enum pot implementa interfețe în Java și aceasta se numește moștenire Enum în Java.
Dat mai jos este un exemplu de moștenire Enum în 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 } }Ieșire:
Aici avem o interfață WeekDays cu o metodă abstractă prototip displaydays (). Apoi definim o clasă enum Days care implementează interfața WeekDays. Aici definim valorile enumerate de DUMINICĂ până SÂMBĂTĂ și, de asemenea, înlocuim metoda displaydays.
În cele din urmă, în metoda principală, accesăm valoarea enum și o afișăm.
întrebări frecvente
Q # 1) Ce se întâmplă dacă dați un corp de metodă în interfață?
Răspuns: Pentru versiunile Java anterioare Java 8, corpul metodei nu este permis în interfață. Dar, din Java 8, putem defini fie metode implicite, fie metode statice în interiorul interfeței.
Q # 2) Poate o interfață să aibă variabile în Java 8?
Răspuns: Putem avea variabile constante în Java 8 folosind modificatori statici și finali. Dar nu putem avea variabile de instanță în interfețele Java. Orice încercare de declarare a variabilelor de instanță într-o interfață va duce la o eroare a compilatorului.
Î # 3) Care sunt îmbunătățirile în interfețele din Java 8?
Răspuns: Cea mai importantă îmbunătățire pentru interfețe în Java 8 este că metodele statice și implicite sunt permise în interfețe. Putem avea metode declarate ca statice sau implicite și le putem defini în interfață.
Q # 4) Putem anula metoda implicită în interfața Java?
Răspuns: Nu. Nu este obligatoriu să înlocuiți metoda implicită din interfață. Acest lucru se datorează faptului că atunci când implementăm o interfață într-o clasă, atunci metoda implicită a clasei este accesibilă clasei de implementare. Prin urmare, folosind obiectul clasei de implementare, putem accesa metoda implicită a interfeței.
Q # 5) Interfețele pot avea câmpuri în Java?
întrebări și răspunsuri pentru interviuri de asistență tehnică pentru cei mai noi
Răspuns: Da, putem avea câmpuri sau variabile în interfețe în Java, dar în mod implicit, toate aceste câmpuri sunt statice, finale și publice.
Concluzie
În acest tutorial, am discutat despre modificările aduse interfețelor în Java 8. Java 8 a introdus metode statice și implicite în interfețe. Mai devreme puteam avea doar metode abstracte în interfață. Dar, începând cu Java 8, putem defini metodele implicite și statice în Java.
De asemenea, Java 8 permite utilizarea expresiilor lambda cu interfețele funcționale din Java. Apoi am discutat și clase abstracte și interfețe și am văzut când să le folosim pe fiecare în Java. De asemenea, am văzut moștenirea enum în Java.
De asemenea, am discutat câteva dintre diferențele dintre extensii și implementări, clasă și interfață, clasă abstractă și interfață etc.
=> Verificați TOATE Tutorialele Java aici.
Lectură recomandată
- Interfață Java și tutorial de clasă abstractă cu exemple
- Interfețe comparabile și comparatoare în Java
- Interfață ListIterator în Java cu exemple
- Setați interfața în Java: Tutorial de setare Java cu exemple
- Interfață Marker în Java: Serializabilă și clonabilă
- Java String length () Metodă cu exemple
- Implementarea Java: crearea și executarea fișierului Java JAR
- Cum se utilizează metoda Java toString?