java中的泛型

泛型

1. 泛型的概念

泛型：是一种未知的数据类型，当我们不知道使用什么数据类型的时候，可以使用泛型。

比如ArrayList集合在定义的时候，不知道集合中都会存储什么类型的数据，所以类型使用泛型

我们简化一下ArrayList的部分源码出来看看：

public class ArrayList<E>{
    public boolean add(E e){}
    public E get(int index){}
}

ArrayList<E>中的E代表未知的类型，Element元素。有的会写成T，即Type类型。

当我们在创建集合对象的时候，就可以确定泛型的数据类型，比如确定为String类型：

ArrayList<String> list = new ArrayList<>();

一旦确定为String类型，ArrayList类的源码中的E将全部替换成String

2. 使用泛型的好处

2.1 创建集合对象，不使用泛型：

好处：集合不使用泛型，默认的类型是Object类型，可以存储任意类型的数据

坏处：不安全，会引发异常

public static void main(String[] args) {
    //创建一个ArrayList集合，但是不使用泛型
    ArrayList list = new ArrayList();

    //可以添加任意类型的数据，比如添加一个字符串
    list.add("abc");
    //再添加个Integer类型的
    list.add(12);
    //再来添加个Character类型的
    list.add('哈');

    //使用foreach来循环取出元素
    for(Object e : list){
        System.out.println(e); 
        //假如我现在想取出里面的字符串的长度，可不可用String的length()方法呢
        //不行，因为添加的时候是add(Object)的，所以传进来的参数都被向上转型为了Object
        //就是说现在我们用的是多态的写法，多态的弊端就是不能用子类特有的方法，比如String类的length()
        //如果真的想用String类的方法，那就要向下造型
        String str = (String) e; //到e = 12的时候，就会引发ClassCastException，因为Integer无法造型为String
        System.out.println(str.length());
    }
}

2.2 创建集合对象，使用泛型

好处：

1. 避免了类型转换的麻烦，存储的是什么类型，取出的是什么类型

2. 把运行期异常（代码运行之后的异常），提升到了编译期（写代码的时候报错），比如泛型的类型我确定为String类之后，在为集合添加元素的时候，却add了个Integer类型进去，那么代码就会变红，提示有错。

   

坏处：泛型是什么类型，就只能存储什么类型的数据

3. 定义含有泛型的类和使用

定义格式：

修饰符 class 类名<代表泛型的变量>{}

代码演示：定义一个泛型GenericClass并且使用它

/*
    定义一个含有泛型的类，模拟ArrayList集合
    用<E>代表未知类型
 */
public class GenericClass<E> {
    private E name;

    public void printName(){
        System.out.println(this.name);
    }

    public void setName(E name){
        this.name = name;
    }
}

在main中使用它

public static void main(String[] args) {
    //不写明泛型是什么，就默认是Object类型
    GenericClass gc1 = new GenericClass();
    //那我就随便传个Integer类进去
    gc1.setName(12);
    gc1.printName();  //12

    //我写明泛型是String类的
    GenericClass<String> gc2 = new GenericClass<>();
    gc2.setName("哈哈");
    gc2.printName(); //哈哈
}

4. 定义含有泛型的方法和使用

定义格式：

修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
    //....
}

调用该方法的时候，传递什么类型的参数，泛型就是什么类型

代码演示:定义一个含有泛型的方法，并且使用它

public class GenericMethod {
    public <E> void method(E e){
        System.out.println(e);
    }
}

在main中使用它

public static void main(String[] args) {
    GenericMethod md = new GenericMethod();
    //传一个String类进去
    md.method("123"); //123
    //传一个Integer类进去
    md.method(25);  //25
    //传一个布尔值进去
    md.method(true); //true
}

我们还可以定义静态的含有泛型的方法，就是在定义方法的时候加多一个static关键字而已

5. 定义和使用含有泛型的接口

5.1 创建含有泛型的接口GenericInterface<I>

public interface GenericInterface<I> {
    public abstract void method(I i);
}

5.2 使用含有泛型的接口

第一种方式：定义接口的实现类，实现接口，指定接口的泛型。就是在创建实现类的时候就确定好了泛型，而不是创建对象的时候确定泛型。Scanner类就是这样

定义GenericInterface<I>接口的实现类GenericInterfaceImpl并指定接口的泛型为String类

public class GenericInterfaceImpl implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

在main中用GenericInterfaceImpl类创建对象，并调用它的method方法

public static void main(String[] args) {
    GenericInterfaceImpl impl = new GenericInterfaceImpl();
    impl.method("含有泛型的接口的方法被调用");
}

补充：Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型默认就是String，它的大概源码如下

public final class Scanner implements Iterator<String>{
    public String next(){}
}

第二种方式：接口使用什么类型，实现类就使用什么泛型，类跟着接口走，相当于定义了一个含有泛型的类。也就是在创建实现类的时候还没确定好泛型，在创建对象的时候才确定好泛型。ArrayList类就是这样

定义GenericInterface<I>接口的实现类GenericInterfaceImpl，该实现类也含有泛型

public class GenericInterfaceImpl<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

在main中用GenericInterfaceImpl类创建对象，指定泛型为Integer类，并调用它的method方法

public static void main(String[] args) {
    GenericInterfaceImpl<Integer> impl = new GenericInterfaceImpl<>();
    impl.method(56); //56
}

6. 泛型通配符

当使用泛型类或者接口时，传递的数据中**，集合的泛型类型不确定，可以通过通配符<?>表示**。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

代码演示：定义一个能遍历所有类型集合的方法

public static void main(String[] args) {
    //创建一个ArrayList集合，指定泛型为String
    ArrayList<String> list1 = new ArrayList<>();
    list1.add("哈哈");
    list1.add("23333");

    //创建一个ArrayList集合，指定泛型为Integer类
    ArrayList<Integer> list2 = new ArrayList<>();
    list2.add(13);
    list2.add(14);
    list2.add(520);

    //调用一个能遍历所有种类集合的方法
    printList(list1);
    printList(list2);
}

//注意：由于泛型没有继承的概念，这里的参数不能写成 ArrayList<Object> list
private static void printList(ArrayList<?> list) {
    //使用迭代器去遍历,先创建一个迭代器对象，集合什么泛型，迭代器就什么泛型
    Iterator<?> iterator = list.iterator();
    while (iterator.hasNext()){
        System.out.println(iterator.next());
    }
}

7. 泛型通配符的高级使用—受限泛型（了解）

在java中，一般对泛型没什么要求，只要是一个类就可以了

但是，我们也可以指定一个泛型的上下限

泛型的上限限定：<? extends E> 代表使用的泛型只能是E类的子类/本身（extends E，E就是最顶级的）

泛型的下限限定：<? super E> 代表使用的泛型只能是E类型的父类/本身（super E，E就是最底层的那个）