Generics com Interfaces em Java: Guia para Iniciantes

O que são Generics?

Em Java, Generics são uma funcionalidade que permite a você escrever e usar classes e métodos que podem operar em qualquer tipo de objeto. Você pode usar tipos genéricos para criar classes, interfaces e métodos que automaticamente operam com diferentes tipos de dados.

Vantagens de Usar Generics

Segurança de tipo: Generics proporcionam segurança de tipo em tempo de compilação e eliminam a necessidade de conversões manuais de tipos.
Reutilização de código: Com generics, você pode escrever um método ou classe que pode ser utilizado com diferentes tipos de dados.
Clareza e robustez: Código usando generics é mais claro e robusto, pois os erros são capturados em tempo de compilação.

Desvantagens de Usar Generics

Complexidade: Pode tornar o código mais complexo e difícil de entender para novatos.
Limitações: Algumas características de generics podem ser limitadas devido à compatibilidade retroativa.
Erros de compilação: Iniciantes podem achar difícil interpretar os erros de compilação relacionados a generics.

Etapa 1: Definindo uma Interface Genérica para Repositório

Podemos usar generics para definir uma interface de repositório que pode ser usada com qualquer tipo de objeto.

public interface Repository<T> {
    void add(T item);
    T get(Long id);
    List<T> getAll();
    void update(Long id, T item);
    void remove(Long id);
}

Aqui, T é um parâmetro de tipo que será substituído pelo tipo de objeto real quando a interface for implementada.

Etapa 2: Implementando a Interface com Generics

Vamos implementar a interface Repository usando generics. Isso permitirá que a mesma classe seja usada para diferentes tipos de dados.

public class GenericRepository<T> implements Repository<T> {
    private Map<Long, T> storage = new HashMap<>();
    private long currentId = 1;

    @Override
    public void add(T item) {
        storage.put(currentId++, item);
    }

    @Override
    public T get(Long id) {
        return storage.get(id);
    }

    @Override
    public List<T> getAll() {
        return new ArrayList<>(storage.values());
    }

    @Override
    public void update(Long id, T item) {
        storage.put(id, item);
    }

    @Override
    public void remove(Long id) {
        storage.remove(id);
    }
}

Etapa 3: Usando a Implementação Genérica

Agora você pode usar a implementação GenericRepository para qualquer tipo de objeto.

public class Main {
    public static void main(String[] args) {
        Repository<User> userRepository = new GenericRepository<>();

        // Adicionar novos usuários
        userRepository.add(new User("John Doe", "johndoe@example.com"));
        userRepository.add(new User("Jane Doe", "janedoe@example.com"));

        // Obter e exibir todos os usuários
        List<User> users = userRepository.getAll();
        for (User user : users) {
            System.out.println(user);
        }

        // Atualizar um usuário
        userRepository.update(1L, new User("Johnathan Doe", "johnathandoe@example.com"));

        // Remover um usuário
        userRepository.remove(1L);
    }
}

Conclusão

Generics adicionam flexibilidade e segurança de tipo ao uso de interfaces em Java. Apesar de sua complexidade inicial, eles oferecem vantagens significativas, como reutilização de código e redução de erros de tempo de execução. Entender como usar generics com interfaces pode tornar seu código Java mais versátil e robusto.

Referências

Last modified: 22 July 2024