Interfaces genéricas

Interfaces genéricas podem ser definidas de forma similar a classes genéricas. No exemplo apresentado:

Interface Containment:
Uma interface genérica chamada Containment é criada para ser implementada por classes que armazenam um ou mais valores.

Método contains():
Declara o método contains(T o), que verifica se um valor específico está presente no objeto chamador.

Esse exemplo mostra como criar interfaces genéricas personalizadas para atender a requisitos específicos, como manipular e verificar elementos armazenados.

// Uma interface genérica que lida com armazenamento.
// Esta interface requer que a classe usuária
// tenha um ou mais valores.
interface Containment<T> { // Interface genérica.
// O método contains() verifica se um item
// especificado está contido dentro de um
// objeto que implementa Containment.
boolean contains(T o);
}
// Implementa Containment usando um array
// para armazenar os valores.
//Toda classe que implemente uma interface genérica também deve ser genérica.
class MyClass<T> implements Containment<T> { //
T[] arrayRef;
MyClass(T[] o) {
arrayRef = o;
}
// Implementa contains()
public boolean contains(T o) {
for(T x : arrayRef)
if(x.equals(o)) return true;
return false;
}
}
class GenIFDemo {
public static void main(String args[]) {
Integer x[] = { 1, 2, 3 };
MyClass<Integer> ob = new MyClass<Integer>(x);
if(ob.contains(2))
System.out.println("2 is in ob");
else
System.out.println("2 is NOT in ob");
if(ob.contains(5))
System.out.println("5 is in ob");
else
System.out.println("5 is NOT in ob");
// A parte a seguir não é válida porque ob
// é um objeto Containment de tipo Integer e
// 9.25 é um valor Double.
// if(ob.contains(9.25)) // Inválido!
// System.out.println("9.25 is in ob");
}
}

Declaração de Interface Genérica:
A interface genérica Containment é declarada usando o parâmetro de tipo T, que especifica o tipo de objetos contidos.

Implementação por uma Classe Genérica:
A classe MyClass implementa a interface Containment, onde T é passado para ambas. Para implementar uma interface genérica, a classe normalmente também deve ser genérica.

Tipos Específicos:
Se a interface for implementada para um tipo específico, como Double, a classe não precisa ser genérica:
class MyClass implements Containment<Double> { // Correto!

Limitação de Parâmetros de Tipo:
É possível limitar o parâmetro de tipo da interface com extends, como em Containment.

Nesse caso, qualquer classe que implemente a interface também deve respeitar o limite, por exemplo:
class MyClass<T extends Number> implements Containment<T> {

Erros Comuns:
Após estabelecer limites para o parâmetro de tipo, não é necessário repeti-los na cláusula implements. Tentar declarar algo como abaixo e resultará em erro.
implements Containment<T extends Number>

Sintaxe Generalizada:
Declaração de interface genérica:
interface nome-interface<lista-parâm-tipo> { // ...

Implementação por uma classe genérica:
class nome-classe<lista-parâm-tipo> implements nome-interface<lista-parâm-tipo> { // ..