泛型接口

泛型接口在接口名后声明类型参数，实现时指定具体类型或保留泛型。

泛型接口定义

// 泛型接口
public interface Generator<T> {
    T generate();
}

实现方式一：指定具体类型

// 实现时指定具体类型
public class StringGenerator implements Generator<String> {
    @Override
    public String generate() {
        return "Hello";
    }
}

public class IntegerGenerator implements Generator<Integer> {
    @Override
    public Integer generate() {
        return 100;
    }
}

实现方式二：保留泛型

// 实现时保留泛型参数
public class GenericGenerator<T> implements Generator<T> {
    @Override
    public T generate() {
        return null;  // 具体实现
    }
}

// 使用时指定类型
GenericGenerator<String> gen = new GenericGenerator<>();
String result = gen.generate();

多类型参数接口

public interface Converter<S, T> {
    T convert(S source);
}

// 指定具体类型
public class StringToIntConverter implements Converter<String, Integer> {
    @Override
    public Integer convert(String source) {
        return Integer.parseInt(source);
    }
}

// 保留泛型
public class GenericConverter<S, T> implements Converter<S, T> {
    @Override
    public T convert(S source) {
        // 具体转换逻辑
        return null;
    }
}

常见泛型接口

Comparator

// Comparator 是泛型接口
Comparator<String> comparator = (s1, s2) -> s1.compareTo(s2);

Comparator<Integer> intComparator = (i1, i2) -> i1 - i2;

Comparable

// 类实现 Comparable 泛型接口
public class Person implements Comparable<Person> {
    private String name;
    private int age;

    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }
}

Function（Java 8）

// Function<T, R> 泛型接口
Function<String, Integer> parseInt = s -> Integer.parseInt(s);
Integer result = parseInt.apply("100");

// Predicate<T> 泛型接口
Predicate<Integer> isPositive = n -> n > 0;
boolean test = isPositive.test(5);  // true

泛型接口使用场景

要点总结

• 泛型接口在接口名后声明类型参数
• 实现时可指定具体类型或保留泛型
• 指定具体类型：实现类不再是泛型类
• 保留泛型：实现类仍是泛型类
• 常见泛型接口：Comparator、Comparable、Function
• Java 8 函数式接口大量使用泛型