从零开始学java--泛型（二）

泛型

目录

泛型

泛型与多态

泛型方法

泛型的界限

---

泛型与多态

不只是类，包括接口、抽象类都可以支持泛型：

    public static void main(String[] args) {
        Score<String> score=new Score<>("数学","aa","优秀");
        Score<?>score1=score;
    }

当子类实现此接口时，我们可以选择在实现类明确泛型类型：

    public static void main(String[] args) {
        A a=new A();
        Integer i=a.study();
    }

    static class A implements Study<Integer>{
//在实现接口或是继承父类时，如果子类是一个普通类，那么可以直接明确对应类型
        @Override
        public Integer study() {
            return 0;
        }
    }

也可以继续使用泛型：

    public static void main(String[] args) {
        A<Integer> a=new A<>();
        Integer i=a.study();
    }

    static class A<T> implements Study<T> {
//让子类继续为一个泛型类，那么可以不明确
        @Override
        public T study() {
            return null;
        }
    }

继承：

    static class A<T>{
    }

    static class B extends A<String>{
        
    }

---

泛型方法

泛型变量不仅仅在泛型类中使用，也可以定义泛型方法。

当某个方法（无论是静态方法还是成员方法）需要接受的参数类型不确定时，我们可以使用泛型来表示：

    public static void main(String[] args) {
        String str=test("10");
    }

    public static <T>T test(T t){ //在返回值类型前添加<>并填写泛型变量表示这是一个泛型方法
        return t;
    }

泛型方法会在使用时自动确定泛型类型，比如我们定义的是类型T作为参数，同样的类型T作为返回值，实际传入的参数是一个字符串类型的值，那么T就会自动变成String类型，因此返回值也是String类型。

泛型方法在很多工具类中也有，比如说Arrays的排序方法：

    public static void main(String[] args) {
        Integer[] arr = {1, 3, 2, 7, 4, 9, 0};
        //不能比较基本数据类型int
        Arrays.sort(arr, new Comparator<Integer>() {
            //通过创建泛型接口的匿名内部类，来自定义排序规则，因为匿名内部类就是接口的实现类，所以这里就明确了类型
            @Override
            public int compare(Integer o1, Integer o2) {  //这个方法会在执行排序时被调用（别人调用我们的实现）
                //想要让数据从大到小排列：
                return o2-o1;
                //compare方法要求返回一个int来表示两个数的大小关系，大于0表示大于，小于0表示小于
                //如果o2比o1大，那么应该排在前面，所以说返回正数表示大于
            }
        });
        System.out.println(Arrays.toString(arr));
    }

可替换为Lambda表达式：

    public static void main(String[] args) {
        Integer[] arr = {1, 3, 2, 7, 4, 9, 0};
        Arrays.sort(arr, (o1, o2) -> o2-o1);
        System.out.println(Arrays.toString(arr));
    }

---

泛型的界限

若现在没有String类型的成绩了，但是成绩依然可能是整数或小数，我们不希望将泛型指定为除数字类型外的其他类型，就需要使用到泛型的上界定义。

只需要在泛型变量的后面添加extends关键字即可指定上界：

public class Score<T extends Number> { //设定类型参数上界，必须是Number或Number的子类
    String name;
    String id;
    T value;

    public Score(String name,String id,T value){
        this.name=name;
        this.id=id;
        this.value=value;
    }
    
    public T getValue() {
        return value;
    }
}

泛型通配符也支持泛型的界限：

    public static void main(String[] args) {
        Score<? extends Integer>score=new Score<>("xm","11",10);
    }

下界只适用于通配符，对于类型变量来说是不支持的。

    public static void main(String[] args) {
        Score<? super Object>score=new Score<>("xm","11",10);
    }

 entends定义的只能存放它自己及其子类，super定义的只能存放它自己及其父类。

限定上界后使用这个对象的泛型成员：

    public static void main(String[] args) {
        Score<? extends Number>score=new Score<>("xm","11",10);
        Number o=score.getValue();  //此时虽然使用的是通配符，但是不再是Object类型，而是对应的上界
    }

限定下界的话，因为还有可能是Object，所以说依然和之前一样：

    public static void main(String[] args) {
        Score<? super Number>score=new Score<>("xm","11",10);
        Object o=score.getValue();
    }