Java——泛型

        什么是泛型？为什么会有泛型的出现？

        一般的类和方法，只能使用一种具体的类型，要么是基本类型，要么是引用类型，或者是自定义的类，但是有没有一个类(方法)，可以同时满足不同类型的参数呢。这就引出了泛型！通俗的讲，泛型就是适用于许多许多类型。

泛型类的语法格式：

    //这里的 T 可以是任意一种类型
    class 泛型类名称 <T>{
        //这里可以使用类型参数
    }

    //实例
    class MyArray <T>{
        pubilc T[]array = (T[])new Object[10];
    }
    //泛型类的使用
    public class Test{
        MyArray<Integer> myArray = new MyArray<>();
    }

泛型方法的语法格式：

// T 是任意一种引用类型
    方法限定符 <T> 返回值类型 方法名称(形参列表){
       //方法体
    }

//实例
    public <T> void swap(T[] array,int i,int j){
        T tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

注意：泛型中的<T>处只能用引用类型，不能使用基本类型。

如果要使用基本类型，需要使用他们的包装类：

byte -> Byte、short -> Short、int -> Integer、char -> Character、long -> Long、boolean -> Boolean、float -> Float

        不仅类可以使用泛型，方法也可以，并且方法使用泛型和类使用泛型也很相似，下面用泛型写一个冒泡排序举例：

        一个int类型数组的冒泡排序和一个自定义类Student的冒泡排序：

public class Demo {
    static class Student{
        public String name;
        public int age;

        public Student(String name,int age){
            this.name = name;
            this.age = age;
        }

        @Override
        public String toString(){
            return "学生{" + "name: " + name + " age: " + age + "}";
        }
    }
//带泛型的比较方法
    public static <T> int compare(T s1,T s2){
        Student a1 = (Student) s1;
        Student a2 = (Student) s2;
        if(a1.age > a2.age){
            return 1;
        }else if(a1.age < a2.age){
            return -1;
        }else{
            return 0;
        }
    }
//带泛型的交换方法
    public static <T> void swap(T[]array,int i,int j){
        T tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }
    //带泛型的冒泡排序
    public static <T> void bubbleSort(T[] array){
        for(int i = 0;i < array.length - 1;i++){
            for(int j = 0;j < array.length - i - 1;j++){
//必须写一个比较方法，不能直接进行比较
                T s1 = array[j];
                T s2 = array[j + 1];
                int tmp = compare(s1,s2);
                if(tmp > 0){
                    swap(array,j,j + 1);
                }
            }
        }
    }
    //不带泛型的冒泡排序
    public static void bubbleSort(int[] array){
        for(int i = 0;i < array.length - 1;i++){
            for(int j = 0;j < array.length - i - 1;j++){
                int tmp = 0;
                if(array[j] > array[j + 1]){
                    tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                }
            }
        }
    }

    public static void main(String[] args) {
//输出结果：[1, 2, 4, 5, 6, 9]
        int[] a1 = {1,6,2,9,4,5};
        bubbleSort(a1);
        System.out.println(Arrays.toString(a1));

//输出结果：[学生{name: 钱六 age: 8}, 学生{name: 王五 age: 17}, 学生{name: 张三 age: 18}, 学生{name: 李四 age: 20}]
        Student[] array = {
                new Student("张三",18),
                new Student("李四",20),
                new Student("王五",17),
                new Student("钱六",8),
        };
        bubbleSort(array);
        System.out.println(Arrays.toString(array));
    }
}

注意：Java的泛型只在编译阶段起作用。