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.