En Java les interfícies són essencials, a l'hora d'establir contractes de classe i garantir la coherència del codi en l'àmbit de la programació Java. Serveix com a model d'una classe, descrivint una sèrie de mètodes que la classe implementadora ha d'implementar. Els desenvolupadors poden aconseguir l'abstracció, la modularitat i el manteniment del seu codi mitjançant l'ús d'interfícies. El diversos tipus d'interfície en Java es tractarà en aquesta secció.
Interfícies de marcadors
Les interfícies de marcador, sovint anomenades interfícies d'etiquetes, són interfícies sense cap mètode declarat. Dit simplement, serveixen com a marcadors, indicant que una classe que implementa la interfície del marcador té propietats o qualitats particulars. L'entorn d'execució de Java i altres eines fan ús d'aquestes API per oferir dades o funcionalitats addicionals. Serialitzable, Clonable i Remot són alguns exemples d'interfícies de marcador a Java.
Interfícies funcionals
Com a part de les millores a les expressions lambda i la programació funcional, es van afegir interfícies funcionals a Java 8. Es diu que és funcional una interfície que té precisament un mètode abstracte. A més, són possibles mètodes per defecte i estàtics. Moltes capacitats de programació funcional de Java, com les expressions lambda i les referències de mètodes, fan ús d'interfícies funcionals. Predicat, Consumer, Function i Supplier són només algunes de les interfícies funcionals integrades que ofereix el paquet java.util.function.
Interfícies de mètode abstracte únic (SAM).
Abans de Java 8, hi havia certs tipus d'interfícies funcionals anomenades interfícies SAM. Aquestes interfícies poden tenir qualsevol nombre de mètodes predeterminats o estàtics, però només un mètode abstracte. Runnable, Comparator i MouseListener són algunes API anteriors a Java 8 que contenen exemples d'interfície SAM. Amb la introducció d'interfícies funcionals a Java 8, les interfícies SAM es poden utilitzar amb expressions lambda i es poden considerar com a interfícies funcionals.
mescla homogènia
Interfícies normals
El tipus d'interfície més freqüent a Java són les interfícies normals. Tenen un o més mètodes abstractes que han d'implementar les classes que implementen la interfície. A partir de Java 8, les interfícies normals també poden contenir mètodes predeterminats i estàtics. Els desenvolupadors utilitzen interfícies normals per especificar les regles o requisits que han de seguir les classes. Llista, conjunt i mapa, tots els quals es troben al paquet java.util, són exemples d'interfícies Java típiques.
Interfícies d'herència múltiple
Java permet que les classes implementin múltiples interfícies, però no admet l'herència de classes múltiples. Les interfícies implementades per una classe per definir simultàniament nombrosos contractes o heretar comportaments es coneixen com a interfícies d'herència múltiple. Una classe pot oferir la funcionalitat descrita per cada interfície mitjançant la implementació de diverses interfícies. Amb l'ajuda d'aquesta funcionalitat, els desenvolupadors poden reutilitzar el codi i augmentar l'adaptabilitat de les seves idees.
Aquí hi ha exemples de codi per a cada tipus d'interfície a Java juntament amb la seva sortida corresponent:
convenció de noms java
Interfícies de marcadors
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 } } Sortida:
true
Interfícies funcionals
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 } } Sortida:
false true
Interfícies de mètode abstracte únic (SAM):
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 } } Sortida:
mylivecricket.in
Performing action
Interfícies normals
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! } } Sortida:
execvp
Hello, World!
Interfícies d'herència múltiple:
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 } } Sortida:
Method 1 Method 2
Aquests exemples demostren l'ús i el comportament de diferents tipus d'interfícies a Java. Podeu executar cada fragment de codi individualment per observar la sortida corresponent.
En conclusió, les interfícies Java ofereixen un mètode potent per especificar contractes i assolir la modularitat del codi. Les interfícies són essencials per al desenvolupament de Java, ja siguin interfícies de marcador que indiquen trets específics, interfícies funcionals que permeten la programació funcional, interfícies normals que defineixen contractes o interfícies d'herència múltiple que combinen diversos contractes. Els desenvolupadors de Java estan millor equipats per crear codi clar i extensible quan coneixen els diferents tipus d'interfície i les seves funcions.