I Java är gränssnitt väsentliga när det gäller att sätta klasskontrakt och garantera kodkonsistens inom Java-programmering. Den fungerar som en klass ritning genom att beskriva ett antal metoder som den implementerande klassen måste implementera. Abstraktionen, modulariteten och underhållbarheten av deras kod kan alla uppnås av utvecklare genom att använda gränssnitt. De olika gränssnittstyper i Java kommer att diskuteras i detta avsnitt.
Markörgränssnitt
Markörgränssnitt, ofta kallade tagggränssnitt, är gränssnitt utan några deklarerade metoder. Enkelt sagt fungerar de som markörer, vilket signalerar att en klass som implementerar markörgränssnittet har särskilda egenskaper eller kvaliteter. Java runtime-miljön och andra verktyg använder dessa API:er för att leverera extra funktionalitet eller data. Serialiserbar, Klonbar och Remote är några instanser av markörgränssnitt i Java.
Funktionella gränssnitt
Som en del av förbättringarna av lambda-uttryck och funktionell programmering lades funktionella gränssnitt till Java 8. Ett gränssnitt som har just en abstrakt metod sägs vara funktionellt. Dessutom är standardmetoder och statiska metoder möjliga. Många Java-funktionella programmeringsmöjligheter, som lambda-uttryck och metodreferenser, använder sig av funktionella gränssnitt. Predikat, Konsument, Funktion och Leverantör är bara några av de inbyggda funktionella gränssnitten som erbjuds av java.util.function-paketet.
Single Abstract Method (SAM)-gränssnitt
Före Java 8 fanns det vissa typer av funktionella gränssnitt som kallas SAM-gränssnitt. Dessa gränssnitt kan ha valfritt antal standardmetoder eller statiska metoder, men bara en abstrakt metod. Runnable, Comparator och MouseListener är några pre-Java 8 API:er som innehåller SAM-gränssnittsexempel. Med introduktionen av funktionella gränssnitt i Java 8 kan SAM-gränssnitt användas med lambda-uttryck och betraktas som funktionella gränssnitt.
ascii tabell java
Normala gränssnitt
Den vanligaste typen av gränssnitt i Java är normala gränssnitt. De har en eller flera abstrakta metoder som klasserna som implementerar gränssnittet måste implementera. Från och med Java 8 kan normala gränssnitt dessutom innehålla standardmetoder och statiska metoder. Normala gränssnitt används av utvecklare för att specificera de regler eller krav som klasser måste följa. Lista, Set och Map, som alla finns i paketet java.util, är exempel på typiska Java-gränssnitt.
Flera arvsgränssnitt
fizzbuzz java
Java tillåter klasser att implementera flera gränssnitt men stöder inte arv av flera klasser. Gränssnitt som implementeras av en klass för att samtidigt definiera flera kontrakt eller ärva beteende är kända som multipla arvsgränssnitt. En klass kan erbjuda den funktionalitet som beskrivs av varje gränssnitt genom att implementera flera gränssnitt. Med hjälp av denna funktionalitet kan utvecklare återanvända kod och öka anpassningsförmågan hos sina idéer.
Här är exempel på kod för varje typ av gränssnitt i Java tillsammans med deras motsvarande utdata:
Markörgränssnitt
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
Funktionella gränssnitt
Functional InterfaceExample.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
SAM-gränssnitt (Single Abstract Method):
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:
hashing i datastruktur
Performing action
Normala gränssnitt
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:
grundläggande java-intervjufrågor
Hello, World!
Flera arvsgränssnitt:
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
Dessa exempel visar användningen och beteendet hos olika typer av gränssnitt i Java. Du kan köra varje kodavsnitt individuellt för att observera motsvarande utdata.
Sammanfattningsvis erbjuder Java-gränssnitt en potent metod för att specificera kontrakt och uppnå kodmodularitet. Gränssnitt är väsentliga för Java-utveckling, oavsett om de är markörgränssnitt som indikerar specifika egenskaper, funktionella gränssnitt som möjliggör funktionell programmering, vanliga gränssnitt som definierar kontrakt eller flera arvsgränssnitt som kombinerar flera kontrakt. Java-utvecklare är bättre rustade att bygga tydlig, utbyggbar kod när de är medvetna om de olika gränssnittstyperna och deras funktioner.