Java 泛型接口

什么是泛型接口？

泛型接口是Java中一种特殊的接口类型，它允许我们在定义接口时使用类型参数，这些参数可以在接口被实现时指定为具体的类型。这种机制提供了更高的类型安全性和代码复用能力，是Java泛型系统的重要组成部分。

泛型接口的基本语法如下：

interface 接口名<T1, T2, ..., Tn> {
    // 接口方法和常量声明
}

其中，T1, T2, ..., Tn 是类型参数，可以在接口内部使用。

泛型接口的基本使用

让我们首先看一个简单的泛型接口示例：

public interface Pair<K, V> {
    K getKey();
    V getValue();
    void setKey(K key);
    void setValue(V value);
}

这个Pair接口定义了一个键值对的抽象，但并没有指定键和值的具体类型，而是使用了类型参数K和V来表示。

实现泛型接口的方式

实现泛型接口有两种主要方式：

1. 实现类指定具体类型

public class StringIntegerPair implements Pair<String, Integer> {
    private String key;
    private Integer value;
    
    public StringIntegerPair(String key, Integer value) {
        this.key = key;
        this.value = value;
    }
    
    @Override
    public String getKey() {
        return key;
    }
    
    @Override
    public Integer getValue() {
        return value;
    }
    
    @Override
    public void setKey(String key) {
        this.key = key;
    }
    
    @Override
    public void setValue(Integer value) {
        this.value = value;
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        StringIntegerPair pair = new StringIntegerPair("age", 25);
        System.out.println(pair.getKey() + ": " + pair.getValue());
        
        // 输出: age: 25
    }
}

2. 实现类保留泛型

public class GenericPair<K, V> implements Pair<K, V> {
    private K key;
    private V value;
    
    public GenericPair(K key, V value) {
        this.key = key;
        this.value = value;
    }
    
    @Override
    public K getKey() {
        return key;
    }
    
    @Override
    public V getValue() {
        return value;
    }
    
    @Override
    public void setKey(K key) {
        this.key = key;
    }
    
    @Override
    public void setValue(V value) {
        this.value = value;
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        // 创建String, Double类型的键值对
        GenericPair<String, Double> salary = new GenericPair<>("月薪", 10000.5);
        System.out.println(salary.getKey() + ": " + salary.getValue());
        
        // 创建Integer, Boolean类型的键值对
        GenericPair<Integer, Boolean> status = new GenericPair<>(404, false);
        System.out.println(status.getKey() + ": " + status.getValue());
        
        // 输出:
        // 月薪: 10000.5
        // 404: false
    }
}

泛型接口中的类型擦除

需要注意的是，Java的泛型是通过类型擦除实现的。这意味着在运行时，所有的泛型信息都会被擦除，泛型类型会被替换为其上界（默认为Object）。

public class Main {
    public static void main(String[] args) {
        GenericPair<String, Integer> pair1 = new GenericPair<>("测试", 100);
        GenericPair<Double, Boolean> pair2 = new GenericPair<>(3.14, true);
        
        // 在运行时，pair1和pair2的类型信息是相同的
        System.out.println(pair1.getClass() == pair2.getClass());  // 输出: true
    }
}

注意

因为类型擦除的关系，不能创建泛型参数的实例，也不能使用instanceof运算符来检测一个对象是否是泛型类型的实例。

泛型接口与通配符

在使用泛型接口时，有时需要使用通配符来增加代码的灵活性：

public void processPairs(List<? extends Pair<String, ?>> pairs) {
    for (Pair<String, ?> pair : pairs) {
        System.out.println(pair.getKey() + ": " + pair.getValue());
    }
}

上面的方法可以处理任何键类型为String，值类型任意的Pair对象列表。

实际应用场景

1. 数据访问层（DAO模式）

泛型接口在数据访问层模式中非常有用，可以创建通用的CRUD操作接口：

public interface GenericDao<T, ID> {
    T findById(ID id);
    List<T> findAll();
    void save(T entity);
    void update(T entity);
    void delete(ID id);
}

具体实现：

public class UserDao implements GenericDao<User, Long> {
    @Override
    public User findById(Long id) {
        // 实现查询用户的逻辑
        return new User(id, "user" + id);
    }
    
    @Override
    public List<User> findAll() {
        // 实现查询所有用户的逻辑
        return Arrays.asList(new User(1L, "user1"), new User(2L, "user2"));
    }
    
    // 其他方法实现...
}

2. 通用容器组件

泛型接口可以用于创建通用的容器组件：

public interface Container<T> {
    void add(T item);
    T get(int index);
    boolean remove(T item);
    int size();
}

public class SimpleContainer<T> implements Container<T> {
    private List<T> elements = new ArrayList<>();
    
    @Override
    public void add(T item) {
        elements.add(item);
    }
    
    @Override
    public T get(int index) {
        return elements.get(index);
    }
    
    @Override
    public boolean remove(T item) {
        return elements.remove(item);
    }
    
    @Override
    public int size() {
        return elements.size();
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        Container<String> names = new SimpleContainer<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        
        for (int i = 0; i < names.size(); i++) {
            System.out.println(names.get(i));
        }
        
        // 输出:
        // Alice
        // Bob
        // Charlie
    }
}

3. 回调机制

泛型接口在处理异步回调时很有用：

public interface Callback<T> {
    void onSuccess(T result);
    void onError(Exception e);
}

public class DataFetcher {
    public void fetchData(String url, Callback<String> callback) {
        try {
            // 模拟异步数据获取
            String data = "从 " + url + " 获取的数据";
            callback.onSuccess(data);
        } catch (Exception e) {
            callback.onError(e);
        }
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        DataFetcher fetcher = new DataFetcher();
        
        fetcher.fetchData("https://example.com/api", new Callback<String>() {
            @Override
            public void onSuccess(String result) {
                System.out.println("数据获取成功: " + result);
            }
            
            @Override
            public void onError(Exception e) {
                System.out.println("发生错误: " + e.getMessage());
            }
        });
    }
}

泛型接口与泛型约束

我们可以使用边界来限制泛型类型参数：

public interface Sortable<T extends Comparable<T>> {
    void sort(List<T> items);
}

public class NaturalSorter<T extends Comparable<T>> implements Sortable<T> {
    @Override
    public void sort(List<T> items) {
        Collections.sort(items);
    }
}

使用示例：

public class Main {
    public static void main(String[] args) {
        Sortable<String> stringSorter = new NaturalSorter<>();
        List<String> names = new ArrayList<>(Arrays.asList("Charlie", "Alice", "Bob"));
        
        stringSorter.sort(names);
        System.out.println(names);  // 输出: [Alice, Bob, Charlie]
        
        Sortable<Integer> intSorter = new NaturalSorter<>();
        List<Integer> numbers = new ArrayList<>(Arrays.asList(3, 1, 2));
        
        intSorter.sort(numbers);
        System.out.println(numbers);  // 输出: [1, 2, 3]
    }
}

泛型接口的多继承

接口可以同时继承多个接口，包括泛型接口：

public interface Identifiable<ID> {
    ID getId();
}

public interface Nameable {
    String getName();
}

public interface IdentifiableEntity<ID> extends Identifiable<ID>, Nameable {
    void setId(ID id);
    void setName(String name);
}

public class User implements IdentifiableEntity<Long> {
    private Long id;
    private String name;
    
    public User(Long id, String name) {
        this.id = id;
        this.name = name;
    }
    
    @Override
    public Long getId() {
        return id;
    }
    
    @Override
    public void setId(Long id) {
        this.id = id;
    }
    
    @Override
    public String getName() {
        return name;
    }
    
    @Override
    public void setName(String name) {
        this.name = name;
    }
}

总结

泛型接口是Java泛型系统的重要组成部分，它扩展了接口的能力，使接口可以适用于多种类型而不失类型安全性。主要优点包括：

1. 提高类型安全 - 在编译时捕获类型错误，而不是运行时
2. 消除强制类型转换 - 减少代码中的类型转换，代码更加清晰
3. 促进代码重用 - 同一个接口可用于多种类型
4. 提供更好的API设计 - 创建更灵活且类型安全的API

在实际开发中，泛型接口广泛应用于集合框架、数据访问层、回调机制和各种通用组件的设计中。掌握泛型接口的使用对于编写高质量的Java代码至关重要。

练习

1. 创建一个泛型接口Converter<S, T>，包含方法T convert(S source)，用于将一种类型转换为另一种类型。
2. 实现上述接口的几个具体类，例如StringToIntegerConverter和IntegerToStringConverter。
3. 创建一个泛型接口Repository<T, ID>，模仿Spring Data JPA的接口，包含基本的CRUD操作。
4. 为上述Repository接口实现一个简单的基于内存的实现类。

进一步学习资源

• Java官方文档中的泛型接口部分
• 《Effective Java》中关于泛型的章节
• 《Java编程思想》中的泛型部分

通过深入学习泛型接口，你将能够设计出更加灵活、类型安全且可复用的Java程序。