I Java er grænseflader afgørende, når det kommer til at sætte klassekontrakter og garantere kodekonsistens inden for Java-programmering. Det fungerer som en klasses blueprint ved at skitsere en række metoder, som den implementerende klasse skal implementere. Abstraktionen, modulariteten og vedligeholdelsen af ​​deres kode kan alle opnås af udviklere ved at anvende grænseflader. Det forskellige grænsefladetyper i Java vil blive diskuteret i dette afsnit.

Markørgrænseflader

Markørgrænseflader, ofte kaldet tag-grænseflader, er grænseflader uden nogen metoder erklæret. Simpelthen sagt tjener de som markører, der signalerer, at en klasse, der implementerer markørgrænsefladen, har særlige egenskaber eller kvaliteter. Java runtime-miljøet og andre værktøjer gør brug af disse API'er til at levere ekstra funktionalitet eller data. Serialiserbar, Klonbar og Remote er nogle forekomster af markørgrænseflader i Java.

Funktionelle grænseflader

Som en del af forbedringerne af lambda-udtryk og funktionel programmering blev der tilføjet funktionelle grænseflader til Java 8. En grænseflade, der har netop én abstrakt metode, siges at være funktionel. Derudover er standard og statiske metoder mulige. Mange Java-funktionelle programmeringsfunktioner, såsom lambda-udtryk og metodereferencer, gør brug af funktionelle grænseflader. Prædikat, forbruger, funktion og leverandør er blot nogle få af de indbyggede funktionelle grænseflader, der tilbydes af java.util.function-pakken.

Single Abstract Method (SAM) grænseflader

Før Java 8 var der visse former for funktionelle grænseflader kaldet SAM-grænseflader. Disse grænseflader kan have et hvilket som helst antal standard- eller statiske metoder, men kun én abstrakt metode. Runnable, Comparator og MouseListener er nogle få præ-Java 8 API'er, der indeholder eksempler på SAM-grænseflader. Med introduktionen af ​​funktionelle grænseflader i Java 8 kan SAM-grænseflader bruges med lambda-udtryk og betragtes som funktionelle grænseflader.

1. ordens logik

Normale grænseflader

Den mest udbredte form for grænseflader i Java er normale grænseflader. De har en eller flere abstrakte metoder, som klasserne, der implementerer grænsefladen, skal implementere. Fra og med Java 8 kan normale grænseflader desuden indeholde standard- og statiske metoder. Normale grænseflader bruges af udviklere til at specificere de regler eller krav, som klasser skal følge. List, Set og Map, som alle findes i java.util-pakken, er eksempler på typiske Java-grænseflader.

Flere arvegrænseflader

Java tillader klasser at implementere flere grænseflader, men understøtter ikke arv af flere klasser. Grænseflader, der implementeres af en klasse til samtidig at definere talrige kontrakter eller arve adfærd, er kendt som multiple arvegrænseflader. En klasse kan tilbyde funktionaliteten skitseret af hver grænseflade ved at implementere flere grænseflader. Ved hjælp af denne funktionalitet kan udviklere genbruge kode og øge tilpasningsevnen af ​​deres ideer.

abstrakt klasse

Her er eksempler på kode for hver type grænseflade i Java sammen med deres tilsvarende output:

Markørgrænseflader

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 } } 

Produktion:

 true 

Funktionelle grænseflader

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 } } 

Produktion:

 false true 

Single Abstract Method (SAM) grænseflader:

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 } } 

Produktion:

hvordan man får den aktuelle dato i java

 Performing action 

Normale grænseflader

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! } } 

Produktion:

hvornår slutter q1

 Hello, World! 

Flere arvegrænseflader:

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 } } 

Produktion:

 Method 1 Method 2 

Disse eksempler demonstrerer brugen og adfærden af ​​forskellige typer grænseflader i Java. Du kan køre hvert kodestykke individuelt for at observere det tilsvarende output.

Som konklusion tilbyder Java-grænseflader en potent metode til at specificere kontrakter og opnå kodemodularitet. Grænseflader er essentielle for Java-udvikling, hvad enten de er markørgrænseflader, der angiver specifikke træk, funktionelle grænseflader, der muliggør funktionel programmering, almindelige grænseflader, der definerer kontrakter, eller flere arvegrænseflader, der kombinerer flere kontrakter. Java-udviklere er bedre rustet til at bygge klar, udvidelig kode, når de er opmærksomme på de forskellige grænsefladetyper og deres funktioner.