I Java er grensesnitt essensielle når det gjelder å sette klassekontrakter og garantere kodekonsistens innen Java-programmering. Den fungerer som en klasses blåkopi ved å skissere en rekke metoder som implementeringsklassen er pålagt å implementere. Abstraksjonen, modulariteten og vedlikeholdbarheten til koden deres kan alle oppnås av utviklere ved å bruke grensesnitt. De ulike grensesnitttyper i Java vil bli diskutert i denne delen.
Markørgrensesnitt
Markørgrensesnitt, ofte kalt tag-grensesnitt, er grensesnitt uten noen metoder som er deklarert. Enkelt sagt fungerer de som markører, og signaliserer at en klasse som implementerer markørgrensesnittet har spesielle egenskaper eller kvaliteter. Java runtime-miljøet og andre verktøy bruker disse API-ene for å levere ekstra funksjonalitet eller data. Serialiserbar, Klonbar og Remote er noen forekomster av markørgrensesnitt i Java.
Funksjonelle grensesnitt
Som en del av forbedringene av lambda-uttrykk og funksjonell programmering ble funksjonelle grensesnitt lagt til Java 8. Et grensesnitt som har nettopp én abstrakt metode sies å være funksjonelt. I tillegg er standard og statiske metoder mulige. Mange Java funksjonelle programmeringsmuligheter, som lambda-uttrykk og metodereferanser, bruker funksjonelle grensesnitt. Predikat, forbruker, funksjon og leverandør er bare noen av de innebygde funksjonelle grensesnittene som tilbys av java.util.function-pakken.
Enkelt abstrakt metode (SAM) grensesnitt
Før Java 8 var det visse typer funksjonelle grensesnitt kalt SAM-grensesnitt. Disse grensesnittene kan ha et hvilket som helst antall standardmetoder eller statiske metoder, men bare én abstrakt metode. Runnable, Comparator og MouseListener er noen få pre-Java 8 APIer som inneholder eksempler på SAM-grensesnitt. Med introduksjonen av funksjonelle grensesnitt i Java 8 kan SAM-grensesnitt brukes med lambda-uttrykk og betraktes som funksjonelle grensesnitt.
null sjekker i java
Normale grensesnitt
Den mest utbredte typen grensesnitt i Java er normale grensesnitt. De har en eller flere abstrakte metoder som klassene som implementerer grensesnittet må implementere. Fra og med Java 8 kan vanlige grensesnitt i tillegg inneholde standard og statiske metoder. Vanlige grensesnitt brukes av utviklere for å spesifisere reglene eller kravene som klasser må følge. List, Set og Map, som alle finnes i java.util-pakken, er eksempler på typiske Java-grensesnitt.
Flere arvegrensesnitt
Java tillater klasser å implementere flere grensesnitt, men støtter ikke arv av flere klasser. Grensesnitt som er implementert av en klasse for samtidig å definere en rekke kontrakter eller arve atferd er kjent som flere arvegrensesnitt. En klasse kan tilby funksjonaliteten skissert av hvert grensesnitt ved å implementere flere grensesnitt. Ved hjelp av denne funksjonaliteten kan utviklere gjenbruke kode og øke tilpasningsevnen til ideene deres.
abstrakt klasse
Her er eksempler på kode for hver type grensesnitt i Java sammen med deres tilsvarende utdata:
Markørgrensesnitt
MarkerInterfaceExample.java
import java.io.Serializable; // Marker Interface interface MyMarkerInterface extends Serializable { } public class MarkerInterfaceExample { public static void main(String[] args) { MyMarkerInterface obj = new MyMarkerInterface() { }; System.out.println(obj instanceof Serializable); // true } } Produksjon:
true
Funksjonelle grensesnitt
FunctionalInterfaceExample.java
import java.util.function.Predicate; public class FunctionalInterfaceExample { public static void main(String[] args) { Predicate isLengthGreaterThan5 = str -> str.length() > 5; System.out.println(isLengthGreaterThan5.test('Hello')); // false System.out.println(isLengthGreaterThan5.test('OpenAI')); // true } } Produksjon:
false true
Enkelt abstrakt metode (SAM)-grensesnitt:
SAMInterfaceExample.java
interface MySAMInterface { void performAction(); } public class SAMInterfaceExample { public static void main(String[] args) { MySAMInterface obj = () -> System.out.println('Performing action'); obj.performAction(); // Performing action } } Produksjon:
heltall dobbel java
Performing action
Normale grensesnitt
NormalInterfaceExample.java
import java.util.List; import java.util.ArrayList; interface MyInterface { void printMessage(); } class MyClass implements MyInterface { @Override public void printMessage() { System.out.println('Hello, World!'); } } public class NormalInterfaceExample { public static void main(String[] args) { MyInterface obj = new MyClass(); obj.printMessage(); // Hello, World! } } Produksjon:
når slutter q1
Hello, World!
Flere arvegrensesnitt:
MultipleInheritanceInterfaceExample.java
interface Interface1 { void method1(); } interface Interface2 { void method2(); } class MyClass implements Interface1, Interface2 { @Override public void method1() { System.out.println('Method 1'); } @Override public void method2() { System.out.println('Method 2'); } } public class MultipleInheritanceInterfaceExample { public static void main(String[] args) { MyClass obj = new MyClass(); obj.method1(); // Method 1 obj.method2(); // Method 2 } } Produksjon:
Method 1 Method 2
Disse eksemplene demonstrerer bruken og oppførselen til forskjellige typer grensesnitt i Java. Du kan kjøre hver kodebit individuelt for å observere den tilsvarende utgangen.
Avslutningsvis tilbyr Java-grensesnitt en potent metode for å spesifisere kontrakter og oppnå kodemodularitet. Grensesnitt er avgjørende for Java-utvikling, enten de er markørgrensesnitt som indikerer spesifikke egenskaper, funksjonelle grensesnitt som muliggjør funksjonell programmering, vanlige grensesnitt som definerer kontrakter, eller flere arvegrensesnitt som kombinerer flere kontrakter. Java-utviklere er bedre rustet til å bygge tydelig, utvidbar kode når de er klar over de ulike grensesnitttypene og deres funksjoner.