Em Java as interfaces são essenciais quando se trata de definir contratos de classe e garantir a consistência do código no domínio da programação Java. Ele serve como um modelo de classe, descrevendo uma série de métodos que a classe implementadora deve implementar. A abstração, modularidade e capacidade de manutenção de seu código podem ser alcançadas pelos desenvolvedores por meio do emprego de interfaces. O vários tipos de interface em Java será discutido nesta seção.
Interfaces de marcadores
Interfaces de marcadores, geralmente chamadas de interfaces de tags, são interfaces sem nenhum método declarado. Simplificando, eles servem como marcadores, sinalizando que uma classe que implementa a interface do marcador possui propriedades ou qualidades específicas. O Java Runtime Environment e outras ferramentas fazem uso dessas APIs para fornecer funcionalidades ou dados extras. Serializable, Cloneable e Remote são algumas instâncias de interfaces de marcadores em Java.
Interfaces Funcionais
Como parte das melhorias nas expressões lambda e na programação funcional, interfaces funcionais foram adicionadas ao Java 8. Uma interface que possui exatamente um método abstrato é considerada funcional. Além disso, métodos padrão e estáticos são possíveis. Muitos recursos de programação funcional Java, como expressões lambda e referências de métodos, fazem uso de interfaces funcionais. Predicado, Consumidor, Função e Fornecedor são apenas algumas das interfaces funcionais integradas oferecidas pelo pacote java.util.function.
Interfaces de Método Abstrato Único (SAM)
Antes do Java 8, havia certos tipos de interfaces funcionais chamadas interfaces SAM. Essas interfaces podem ter qualquer número de métodos padrão ou estáticos, mas apenas um método abstrato. Runnable, Comparator e MouseListener são algumas APIs pré-Java 8 que contêm exemplos de interface SAM. Com a introdução de interfaces funcionais no Java 8, as interfaces SAM podem ser usadas com expressões lambda e consideradas interfaces funcionais.
série de fibonacci em c
Interfaces normais
O tipo de interface mais comum em Java são as interfaces normais. Eles possuem um ou mais métodos abstratos que as classes que implementam a interface devem implementar. A partir do Java 8, as interfaces normais podem conter adicionalmente métodos padrão e estáticos. Interfaces normais são usadas por desenvolvedores para especificar as regras ou requisitos que as classes devem seguir. List, Set e Map, todos encontrados no pacote java.util, são exemplos de interfaces Java típicas.
Múltiplas interfaces de herança
Java permite que classes implementem múltiplas interfaces, mas não suporta herança de múltiplas classes. As interfaces implementadas por uma classe para definir simultaneamente vários contratos ou herdar comportamento são conhecidas como interfaces de herança múltipla. Uma classe pode oferecer a funcionalidade descrita por cada interface implementando diversas interfaces. Com a ajuda desta funcionalidade, os desenvolvedores podem reutilizar código e aumentar a adaptabilidade de suas ideias.
Aqui estão exemplos de código para cada tipo de interface em Java junto com sua saída correspondente:
string.formato em java
Interfaces de marcadores
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 } } Saída:
true
Interfaces Funcionais
FuncionalInterfaceExample.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 } } Saída:
false true
Interfaces de método abstrato ú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 } } Saída:
é um relacionamento
Performing action
Interfaces normais
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! } } Saída:
atriz Zeenat Aman
Hello, World!
Interfaces de herança múltipla:
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 } } Saída:
Method 1 Method 2
Estes exemplos demonstram o uso e o comportamento de diferentes tipos de interfaces em Java. Você pode executar cada trecho de código individualmente para observar a saída correspondente.
Concluindo, as interfaces Java oferecem um método potente para especificar contratos e obter modularidade de código. As interfaces são essenciais para o desenvolvimento Java, sejam elas interfaces marcadoras que indicam características específicas, interfaces funcionais que permitem a programação funcional, interfaces regulares que definem contratos ou interfaces de herança múltipla que combinam vários contratos. Os desenvolvedores Java estão mais bem equipados para construir código claro e extensível quando conhecem os vários tipos de interface e suas funções.