In Java zijn interfaces essentieel als het gaat om het instellen van klassencontracten en het garanderen van codeconsistentie op het gebied van Java-programmeren. Het dient als blauwdruk voor een klasse door een aantal methoden te schetsen die de implementerende klasse moet implementeren. De abstractie, modulariteit en onderhoudbaarheid van hun code kunnen allemaal door ontwikkelaars worden bereikt door interfaces te gebruiken. De verschillende interfacetypen in Java zal in deze sectie worden besproken.
Markerinterfaces
Markerinterfaces, vaak taginterfaces genoemd, zijn interfaces zonder dat er methoden zijn gedeclareerd. Simpel gezegd dienen ze als markers, wat aangeeft dat een klasse die de markerinterface implementeert bepaalde eigenschappen of kwaliteiten heeft. De Java runtime-omgeving en andere tools maken gebruik van deze API’s om extra functionaliteit of data te leveren. Serializable, Cloneable en Remote zijn enkele voorbeelden van markerinterfaces in Java.
Functionele interfaces
Als onderdeel van de verbeteringen aan lambda-expressies en functioneel programmeren zijn functionele interfaces toegevoegd aan Java 8. Een interface die precies één abstracte methode heeft, wordt functioneel genoemd. Bovendien zijn standaard- en statische methoden mogelijk. Veel functionele Java-programmeermogelijkheden, zoals lambda-expressies en methodereferenties, maken gebruik van functionele interfaces. Predicate, Consumer, Function en Supplier zijn slechts enkele van de ingebouwde functionele interfaces die worden aangeboden door het java.util.function-pakket.
Single Abstract Method (SAM)-interfaces
Vóór Java 8 waren er bepaalde soorten functionele interfaces, SAM-interfaces genoemd. Deze interfaces kunnen een willekeurig aantal standaard- of statische methoden hebben, maar slechts één abstracte methode. Runnable, Comparator en MouseListener zijn enkele pre-Java 8 API's die voorbeelden van SAM-interfaces bevatten. Met de introductie van functionele interfaces in Java 8 kunnen SAM-interfaces worden gebruikt met lambda-expressies en worden beschouwd als functionele interfaces.
middelste knop in css
Normale interfaces
De meest voorkomende soort interfaces in Java zijn normale interfaces. Ze hebben een of meer abstracte methoden die de klassen die de interface implementeren, moeten implementeren. Vanaf Java 8 kunnen normale interfaces bovendien standaard- en statische methoden bevatten. Normale interfaces worden door ontwikkelaars gebruikt om de regels of vereisten te specificeren waaraan klassen moeten voldoen. List, Set en Map, die allemaal te vinden zijn in het java.util-pakket, zijn voorbeelden van typische Java-interfaces.
Meerdere erfenisinterfaces
1 miljard tot miljoen
Java staat toe dat klassen meerdere interfaces implementeren, maar ondersteunt geen overerving van meerdere klassen. Interfaces die door een klasse worden geïmplementeerd om tegelijkertijd meerdere contracten te definiëren of gedrag te erven, staan bekend als meervoudige overervingsinterfaces. Een klasse kan de functionaliteit bieden die door elke interface wordt beschreven door verschillende interfaces te implementeren. Met behulp van deze functionaliteit kunnen ontwikkelaars code hergebruiken en de aanpasbaarheid van hun ideeën vergroten.
Hier zijn voorbeelden van code voor elk type interface in Java, samen met de bijbehorende uitvoer:
Markerinterfaces
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 } } Uitgang:
true
Functionele interfaces
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 } } Uitgang:
false true
Single Abstract Method (SAM)-interfaces:
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 } } Uitgang:
laptop insteeksleutel
Performing action
Normale interfaces
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! } } Uitgang:
css-lijsten
Hello, World!
Meerdere erfenisinterfaces:
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 } } Uitgang:
Method 1 Method 2
Deze voorbeelden demonstreren het gebruik en gedrag van verschillende soorten interfaces in Java. U kunt elk codefragment afzonderlijk uitvoeren om de bijbehorende uitvoer te bekijken.
Kortom, Java-interfaces bieden een krachtige methode voor het specificeren van contracten en het bereiken van codemodulariteit. Interfaces zijn essentieel voor de ontwikkeling van Java, of het nu gaat om markerinterfaces die specifieke kenmerken aangeven, functionele interfaces die functioneel programmeren mogelijk maken, reguliere interfaces die contracten definiëren, of meerdere overervingsinterfaces die verschillende contracten combineren. Java-ontwikkelaars zijn beter toegerust om duidelijke, uitbreidbare code te bouwen als ze op de hoogte zijn van de verschillende interfacetypen en hun functies.