JavaSE笔记（三）：泛型

泛型程序设计

为了统计学生成绩，需要设计一个Score对象，包括课程名称、课程号、课程成绩，但是成绩分为两种，一种是以优秀、良好、及格、不及格来作为结果，另一种是60.0、97.5这样的数字分数，不同的课程可能是用不同的累心，那应该如何设计这样的Score类。
如果我们使用以下方法：

package org.ep;

public class Score {
    String name;
    String id;
    Object value;       //Object是所有类的父类，所以既能存放String又能存放Integer
    
    public Score(String name, String id, Object value) {
        this.name = name;
        this.id = id;
        this.value = value;
    }
}

以上的方法虽然很好地解决了多种类型存储问题，但是Object类型在编译阶段并不具有良好的类型判断能力，对于使用者来说不是很容易判断存储的类型到底是String还是Integer，所以只能在取值的时候进行强制类型转换，又无法保证在编译器的安全性。所以说这种方案不是最好的。

为了解决以上问题，可以使用泛型，能在编译阶段就检查类型安全，提升开发效率。

泛型类

泛型其实就是一个待定类型，我们可以使用一个特殊的名字表示泛型，在使用时不需要定义是什么类型。

我们可以将一个类定义成一个泛型类：

package org.ep;

public class Score<T> {     //泛型类需要使用<>，我们需要在里面添加1~N个类型变量
    String name;
    String id;
    T value;

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

使用时需要明确需要使用的类型：

package org.ep;

public class Main {
    public static void main(String[] args) {
        Score<String> score = new Score<String>("csapp", "341", "优秀");
        String value = score.value;
        System.out.println(value);
    }
}

优秀

泛型将数据类型的确定控制在了编译阶段，在编写代码的时候就能明确泛型的类型，如果类型不符合则不能通过编译。

因为是具体使用对象是才会明确具体类型，所以静态方法中是不能用的。而且不能通过不确定的类型变量直接创建对象和对应的数组。

如果要让某个变量支持引用确定了任意类型的泛型，那么可以用?通配符：

package org.ep;

public class Main {
    public static void main(String[] args) {
        Test<?> test = new Test<Integer>();
        test = new Test<String>();
        Object o = test.value;
    }
}

这样，我们就创建了一个Test泛型类的test对象，这个对象可以分配给不同类型的Test对象，比如Test<Integer> 或 Test<String>，因为通配符 ? 表示不确定的泛型类型。但是注意，如果使用通配符，那么由于类型不确定，所以说具体类型同样会变成Object。

当然，泛型变量不止可以只有一个，如果需要使用多个的话，我们也可以定义多个：

package org.ep;

public class Test<A, B, C> {
    A a;
    B b;
    C c;
}

这样在使用时就需要将三种类型都明确指定：

package org.ep;

public class Main {
    public static void main(String[] args) {
        Test<String, Integer, Character> test = new Test<>();
        test.a = "EP";
        test.b = 13;
        test.c = 't';
    }
}

只要在类中，都可以使用类型变量：

package org.ep;

public class Test<T> {
    private T value;
    
    public void setValue(T value) {
        this.value = value;
    }
    
    public T getValue() {
        return value;
    }
}

只不过，泛型只能确定为一个引用类型，基本类型（int、double等）是不支持的。如果要存放基本数据类型的值，我们只能使用对应的包装类：

package org.ep;

public class Main {
    public static void main(String[] args) {
        Test<Integer> test = new Test<>();
    }
}

但是因为基本类型的数组时引用类型，所以可以直接使用：

package org.ep;

public class Main {
    public static void main(String[] args) {
        Test<int[]> test = new Test<>();
    }
}

通过使用泛型，我们就可以将某些不明确的类型在具体使用时再明确。

泛型与多态

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

package org.ep;

public interface Study<T> {
    T test();       //定义了一个返回值为T的抽象方法
}

当子类实现此接口时，我们可以选择在实现类明确泛型类型，或是继续使用此泛型让具体创建的对象来确定类型：

package org.ep;

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

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

继续使用泛型：

package org.ep;

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

    public static class A<T> implements Study<T> {
        public T test() {
            return null;
        }
    }
}

继承也是相同的：

static class A<T> {
    
}

static class B extends A<String> {

}

泛型方法

类型变量不只有在泛型类中才能使用，也可以定义泛型方法。

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

package org.ep;

public class Main {
    public static void main(String[] args) {
        System.out.println(test("enen"));
    }

    private static <T> T test(T t) {
        return t;
    }
}

enen

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

package org.ep;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        String[] strings = new String[1];
        Main main = new Main();
        main.add(strings, "hello");     //自动识别T类型为字符串类型
        System.out.println(Arrays.toString(strings));
    }

    private static <T> void add(T[] arr, T t) {     //将一个类型变量加到同类型变量的数组的头
        arr[0] = t;
    }
}

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

public static void main(String[] args) {
    Integer[] arr = {1, 4, 5, 2, 6, 3, 0, 7, 9, 8};
    Arrays.sort(arr, new Comparator<Integer>() {        //通过创建泛型接口的匿名内部类，来自定义排序规则，因为匿名内部类就是接口的实现类，所以说这里就明确了类型
        @Override
        public int compare(Integer o1, Integer o2) {   //两个需要比较的数会在这里给出
            return o2 - o1;    
          	//compare方法要求返回一个int来表示两个数的大小关系，大于0表示大于，小于0表示小于
          	//这里直接o2-o1就行，如果o2比o1大，那么肯定应该排在前面，所以说返回正数表示大于
        }
    });
    System.out.println(Arrays.toString(arr));
}

Arrays.sort() 方法可以接受一个比较器（Comparator）作为参数，这是因为 Java 提供了方法重载（Overloading）的机制，允许同一个方法接受不同类型或数量的参数。在 Arrays 类中，有多个重载的 sort 方法，其中一些接受不同类型的比较器。

Arrays.sort(T[] a, Comparator<? super T> c) 方法接受一个泛型数组 a 和一个比较器 c，用于对数组进行排序。这个方法的定义允许通过传递一个自定义的比较器来指定排序规则。

比较器是一种实现了 Comparator 接口的类，该接口定义了一个 compare 方法，用于比较两个对象的顺序。你可以通过实现 compare 方法来自定义排序规则，然后将这个比较器对象传递给 Arrays.sort() 方法。

根据前面学习的Lambda表达式，这种只有一个方法需要实现的接口，就可以使用Lambda表达式实现Comparator接口：

package org.ep;

import java.util.Arrays;

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

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

因此，泛型实际上在很多情况下都能够极大地方便我们对于程序的代码设计

泛型的界限

现在有一个新的需求，现在没有String类型的成绩了，但是成绩依然可能是整数，也可能是小数，这时我们不希望用户将泛型指定为除数字类型外的其他类型，我们就需要使用到泛型的上界定义：

package org.ep;

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

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

只要在泛型变量后面添加extends关键字就可以指定上界，使用时，具体类型只能是我们指定的上界类型或是上界类型的子类，不得是其他类型。否则一律报错：

同样的，当我们在使用变量时，泛型通配符也支持泛型的界限：

package org.ep;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Score<? extends Integer> score = new Score<>("E", "13", 60);
    }
}

同样的，泛型也有下界：

只不过下界仅适用于通配符，对于类型变量来说是不支持的。
下界的限定就像这样：

限定了上界后，再来使用这个对象的泛型成员，会变成什么类型呢？

package org.ep;

public class Score<T> {
    private final String name;
    private final String id;
    private final T value;

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

    public T getScore() {
        return value;
    }
}

package org.ep;

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        Score<? extends Number> score = new Score<>("E", "13", 60);
        Number n = score.getScore();
    }
}

也就是说此时虽然使用了通配符，但是因为限定了上界，所以泛型变量已经不再是Object类型，而是变成了上界Number类型。但是如果限定下界，就不会改变泛型变量的类型，保持Object不变。

通过给设定泛型上限，我们就可以更加灵活地控制泛型的具体类型范围。

类型擦除

类型擦除是一种编译期优化，旨在确保泛型代码与旧版非泛型代码兼容，并且在运行时减少了泛型信息的存储开销。泛型的类型擦除主要包括以下几个方面：

1. 类型参数擦除：在编译时，泛型类型的类型参数会被擦除，例如，List<Integer> 和 List<String> 在运行时都被视为 List