简单了解一下Java中的泛型

泛型可以用来指定容器，而由编译器来保证类型的正确性。通俗易懂的讲，泛型就是限制数据类型为一种参数。

比如说： 我们定义了List<String>，就是要求list内必须存放String类型的数据，如果放了其他类型，就会报错；同理，如果使用泛型也是一样的，定义List<T>，就是要求list内存放T类型数据，只不过此时可以编写应用于多种类型的代码。

泛型的类型

• E - Element (在集合中使用，因为集合中存放的是元素)

• T - Type（表示Java 类，包括基本的类和我们自定义的类）

• K - Key（表示键，比如Map中的key）

• V - Value（表示值）

• N - Number（表示数值类型）

• ？ - （表示不确定的java类型）

泛型的使用

泛型可以使用在类、方法、接口上。

泛型只支持引用数据类型。

如果不写泛型，类型默认是Object。

一、泛型类

使用场景：

当一个类中，某个变量的数据类型不确定时，就可以定义带有泛型的类。

定义格式：

修饰符 class 类名<类型> { }

代码：

public class MyList<E> {
    Object[] obj = new Object[10];
    int size;
   
    public boolean add(E e) {
        obj[size] = e;
        size++;
        return true;
    }
    
    public E get(int index){
        return (E)obj[index];
    }
    
    @Override
    public String toString() {
        return Arrays.toString(obj);
    }
}

public class Test1 {
    public static void main(String[] args) {
        MyList<String> list = new MyList<>();
        list.add("element");
        System.out.println(list);
        System.out.println(list.get(0));
        
        MyList<Integer> list1 = new MyList<>();
        list1.add(0);
        System.out.println(list1);
        System.out.println(list1.get(0));
    }
}

如果一个类的后面有<E>，表示这个类是一个泛型类，其中的E表示记录数据的类型。

创建泛型类的对象时，必须要给这个泛型确定的数据类型。

二、泛型方法

使用场景：

方法中形参类型不确定时，在方法申明上定义自己的泛型

定义格式：

修饰符 <类型> 返回值类型 方法名(类型 变量名) { }

代码：

定义一个添加元素的类，类中一个静态方法addAll，用来添加多个集合的元素

public class AddElement{

    public static <T> void addElement(ArrayList<T> list, T t1, T t2, T t3) {
        list.add(t1);
        list.add(t2);
        list.add(t3);
    }
}

public class Test {
    public static void main(String[] args) {
        // String类型数据
        ArrayList<String> list = new ArrayList<>();
        ListUtil.addAll(list,"aaa", "bbb","ccc");
        System.out.println(list);
        
        // Integer类型数据
        ArrayList<Integer> list1 = new ArrayList<>();
        ListUtil.addAll(list1,1, 2,3);
        System.out.println(list1);
    }
}

三、泛型接口

定义格式：

修饰符 interface 接口名<类型> {}

泛型接口使用方法（代码）：

• 实现类确定出具体的数据类型

public class MyListOne implements List<String> {
        // ......
}

public class Test1 {
    public static void main(String[] args) {
        // 由于在接口已经写了String，不用再次写泛型
        MyListOne list1 = new MyListOne();
        list1.add("element");
    }     
}          

• 实现类也使用泛型，创建对象时再确定具体类型

public class MyListTwo<E> implements List<E> {
        // ......
}

public class Test2 {
    public static void main(String[] args) {
        
        MyListTwo<String> list2 = new MyListTwo();
        list2.add("element");
    }     
}  

泛型的好处：

• 避免强制类型转换

• 把运行时期的问题提前到了编译期间