Java基础---泛型

泛型概述以及泛型类

• 泛型就是类型参数化，处理的数据类型不是固定的，而是可以作为参数传入；
• 泛型的核心: 告诉编译器想使用什么类型，然后编译器帮你处理一切；

public class GenericClass {

    private static class Pair{
        private U first;
        private V second;

        public Pair(U first, V second) {
            this.first = first;
            this.second = second;
        }
        public U getFirst() {
            return first;
        }
        public V getSecond() {
            return second;
        }
    }

    public static void main(String[] args){
        Pairpair = new Pair<>("zhangsan", 23);
    }
}

为什么Java不直接使用普通的Object类呢 ？

public class GenericClass2 {

    private static class Pair{ //　Generic Class
        private Object first;
        private Object second;

        public Pair(Object first, Object second) {
            this.first = first;
            this.second = second;
        }

        public Object getFirst() {
            return first;
        }

        public Object getSecond() {
            return second;
        }
    }

    public static void main(String[] args){
        Pair pair = new Pair("zhangsan", 23);
        String name = (String) pair.getFirst();
        Integer age = (Integer) pair.getSecond();
    }
}

其实是可以这样的，而且Java的内部就是这样实现的。

• Java有Java编译器和Java虚拟机，编译器将Java源代码转换为.class文件，虚拟机加载并运行.class文件。
• 对于泛型类，Java编译器会将泛型代码转换为普通的非泛型代码，就像上面的普通Pair类代码及其使用代码一样，将类型参数T擦除，替换为Object，插入必要的强制类型转换。Java虚拟机实际执行的时候，它是不知道泛型这回事的，它只知道普通的类及代码。
• 再次强调，Java泛型是通过擦除实现的，类定义中的类型参数如T会被替换为Object，在程序运行过程中，不知道泛型的实际类型参数，比如Pair，运行中只知道Pair，而不知道Integer。

那为什么还要使用泛型呢? 泛型有两个好处:

• 更好的安全性；
• 更高的可读性；

泛型方法

• 要定义泛型方法，只需要将泛型参数列表置于返回值前；
• 注意: 一个方法是不是泛型的, 和它所在的类是不是泛型没有任何关系；
• 泛型方法调用的时候，不需要指定类型参数的实际类型，Java编译器会推断出来；

public class GenericMethod {

    public static  int indexOf(T[] arr, T ele){ // Generic Method
        for(int i = 0; i < arr.length; i++){
            if(arr[i].equals(ele))
                return i;
        }
        return -1;
    }

    public static void main(String[] args){
        System.out.println(indexOf(new Integer[]{1, 3, 5, 7}, 5));
        System.out.println(indexOf(new String[]{"zhangsan", "lisi", "wangwu"}, "lisi"));
    }
}

实际上泛型类和泛型方法没有联系:

//泛型类的泛型和泛型方法的泛型没有一点关系
public class GenericClassMethod {

    public  void testMethod(T t){
        System.out.println(t.getClass().getName());
    }

    public  T testMethod1(T t){
        return t;
    }
    
    public static void main(String[] args){
        GenericClassMethodgcm = new GenericClassMethod<>();
        gcm.testMethod("generic");
        Integer res = gcm.testMethod1(new Integer(10));
        System.out.println(res);
    }
}

// java.lang.String
// 10

三、泛型接口

接口也可以是泛型的，例如，Java中的Comparable和Comparator：

public interface Comparable {
    public int compareTo(T o);
}
public interface Comparator {
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

四、extends、<=、参数类型必须是给定的或者子类型

1、上界为某个具体类

• 可以使用extends来限定一个上界，此时参数类型必须是给定的类型或者其子类型；
• 比如定义一个NumberPair类，限定两个参数类型必须是Number或者子类型，这样限定之后，在子类中，first、second变量就可以当做Number进行处理了，比如调用Number类中的方法doubleValue()、intValue等；

// 示例代码，(省略了上面的Pair类)
public class GenericExtends {

    private static class NumberPair extends Pair{

        public NumberPair(U first, V second) { // must realize (achieve)
            super(first, second);
        }

        public double getSum(){
            return getFirst().doubleValue() + getSecond().intValue();
        }
    }

    public static void main(String[] args){
        NumberPairnp = new NumberPair<>(3.3, 3); // 可以是 Number的子类，即 <=
        System.out.println(np.getSum());
    }
}

2.上界为某个接口

在泛型方法中，一种常见的限定类型是必须实现Comparable接口:

• 下面的例子，要进行元素的比较，要求元素必须实现Comparable接口， 所以给类型参数设置了一个上边界Comparable 必须实现Comparable接口；
• 可以理解为： T是一种数据类型，必须实现Comparable,且必须可以与相同类型的元素进行比较；

ublic class GenericExtends2 {

    // 要进行元素的比较，要求元素必须实现Comparable接口
    // 所以给类型参数设置了一个上边界Comparable,T 必须实现Comparable接口
    public static  T getMax(T[] arr){
        T max = arr[0];
        for(int i = 0; i < arr.length; i++){
            if(arr[i].compareTo(max) > 0){
                max = arr[i];
            }
        }
        return max;
    }

    // 不过上面这么写会有警告 因为Comparable是一个泛型接口，它也需要一个类型参数，所以下面的写法比较好
    // 理解: T是一种数据类型，必须实现Comparable,且必须可以与相同类型的元素进行比较
    public static  > T getMax2(T[] arr){
        T max = arr[0];
        for(int i = 0; i < arr.length; i++){
            if(arr[i].compareTo(max) > 0){
                max = arr[i];
            }
        }
        return max;
    }
}

3.上界为其他参数类型

• 这里模仿ArrayList来创建一个类， 并想着实现其中的addAll()方法，但是如果不使用一个上界的话，会出现无法添加子类的情况，看下面的代码，Number的集合理应可以添加Integer类型的元素。

public class GenericExtends3 {

    // seems like ArrayList
    private static class DynamicArray{

        private static final int DEFAULT_CAPACITY = 10;
        private int size;
        private Object[] data;

        public DynamicArray() {
            this.data = new Object[DEFAULT_CAPACITY];
        }
        private void ensureCapacity(int minCapacity){  // simulate ArrayList
            int oldCapacity = data.length;
            if(oldCapacity >= minCapacity)
                return;
            int newCapacity = oldCapacity * 2;
            if(newCapacity < minCapacity) //如果扩展2倍还是小于minCapacity，就直接扩展成为minCapacity
                newCapacity = minCapacity;
            data = Arrays.copyOf(data, newCapacity);
        }

        public void add(E e){
            ensureCapacity(size + 1);
            data[size++] = e;
        }

        public E get(int index){
            return (E)data[index];
        }

        public int size(){
            return size;
        }

        public E set(int index, E e){
            E oldValue = get(index);
            data[index] = e;
            return oldValue;
        }
        
        public void addAll(DynamicArrayarr){
            for(int i = 0; i < arr.size; i++){
                add(arr.get(i));
            }
        }
    }

    public static void main(String[] args){
        DynamicArraynumbers = new DynamicArray<>();
        DynamicArrayints = new DynamicArray<>();
        ints.add(10);
        ints.add(20);
//        numbers.addAll(ints); // compile error
    }
}

那个需求感觉上是可以，但是通过反证法可以发现是行不通的，看下面代码以及解释:

DynamicArraynumbers = new DynamicArray<>();
numbers = ints; // 假设合法
numbers.add(new Double(3.3)); // 那么这一样也可以，此时因为numbers和ints指向的同一个堆区空间，则ints中出现double类型值，显然不合理

//再看一个例子
List