En Java, las interfaces son esenciales cuando se trata de establecer contratos de clases y garantizar la coherencia del código en el ámbito de la programación Java. Sirve como modelo de una clase al describir una serie de métodos que la clase implementadora debe implementar. Los desarrolladores pueden lograr la abstracción, la modularidad y la capacidad de mantenimiento de su código mediante el empleo de interfaces. El varios tipos de interfaz en Java se discutirá en esta sección.

Interfaces de marcador

Las interfaces de marcador, a menudo llamadas interfaces de etiqueta, son interfaces sin ningún método declarado. En pocas palabras, sirven como marcadores, indicando que una clase que implementa la interfaz del marcador tiene propiedades o cualidades particulares. El entorno de ejecución de Java y otras herramientas utilizan estas API para ofrecer funciones o datos adicionales. Serializable, Clonable y Remota son algunos ejemplos de interfaces de marcador en Java.

Interfaces funcionales

Como parte de las mejoras a las expresiones lambda y la programación funcional, se agregaron interfaces funcionales a Java 8. Se dice que una interfaz que tiene precisamente un método abstracto es funcional. Además, son posibles los métodos predeterminados y estáticos. Muchas capacidades de programación funcional de Java, como expresiones lambda y referencias de métodos, utilizan interfaces funcionales. Predicado, Consumidor, Función y Proveedor son solo algunas de las interfaces funcionales integradas que ofrece el paquete java.util.function.

Interfaces de método abstracto único (SAM)

Antes de Java 8, existían ciertos tipos de interfaces funcionales llamadas interfaces SAM. Estas interfaces pueden tener cualquier número de métodos estáticos o predeterminados, pero solo un método abstracto. Runnable, Comparator y MouseListener son algunas API anteriores a Java 8 que contienen ejemplos de interfaz SAM. Con la introducción de interfaces funcionales en Java 8, las interfaces SAM pueden usarse con expresiones lambda y considerarse interfaces funcionales.

programas de ejemplo de programación c

Interfaces normales

El tipo de interfaz más frecuente en Java son las interfaces normales. Tienen uno o más métodos abstractos que las clases que implementan la interfaz deben implementar. A partir de Java 8, las interfaces normales pueden contener además métodos estáticos y predeterminados. Los desarrolladores utilizan interfaces normales para especificar las reglas o requisitos que deben seguir las clases. List, Set y Map, todos los cuales se encuentran en el paquete java.util, son ejemplos de interfaces Java típicas.

Múltiples interfaces de herencia

Java permite que las clases implementen múltiples interfaces pero no admite la herencia de múltiples clases. Las interfaces implementadas por una clase para definir simultáneamente numerosos contratos o heredar comportamientos se conocen como interfaces de herencia múltiple. Una clase puede ofrecer la funcionalidad descrita por cada interfaz implementando varias interfaces. Con la ayuda de esta funcionalidad, los desarrolladores pueden reutilizar el código y aumentar la adaptabilidad de sus ideas.

Aquí hay ejemplos de código para cada tipo de interfaz en Java junto con su salida correspondiente:

cadena java de matriz

Interfaces de marcador

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

Producción:

 true 

Interfaces funcionales

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

Producción:

 false true 

Interfaces del método abstracto único (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 } } 

Producción:

tipo de fecha mecanografiada

 Performing action 

Interfaces normales

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

Producción:

genericidad en java

 Hello, World! 

Múltiples interfaces de herencia:

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

Producción:

 Method 1 Method 2 

Estos ejemplos demuestran el uso y comportamiento de diferentes tipos de interfaces en Java. Puede ejecutar cada fragmento de código individualmente para observar el resultado correspondiente.

En conclusión, las interfaces Java ofrecen un método potente para especificar contratos y lograr modularidad del código. Las interfaces son esenciales para el desarrollo de Java, ya sean interfaces de marcador que indican rasgos específicos, interfaces funcionales que permiten la programación funcional, interfaces regulares que definen contratos o interfaces de herencia múltiple que combinan varios contratos. Los desarrolladores de Java están mejor equipados para crear código claro y ampliable cuando conocen los distintos tipos de interfaz y sus funciones.