Java泛型概述

泛型概述

Java 泛型(Generic)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。

把一个集合中的内容限制为一个特定的数据类型,这就是泛型背后的核心思想。

 

为什么要有泛型(Generic)?

1)解决元素存储的安全性问题

2)解决获取数据元素时,需要类型强转的问题

Java泛型概述_第1张图片

当我们将一个元素放入集合中,集合不会记住此元素的类型,当再次从集合中取出此元素时,该元素的编译类型变成了Object类型,但其运行时类型仍然为其本身类型。我们可以通过以下的例子来说明:

public class GenericDemo {
    public static void main(String[] args) {
        List list = new ArrayList(); // 创建无泛型的集合,此时list默认的类型为Object类型
        list.add("zhaowajun"); // 先添加一个字符串型元素
        list.add(10); // 再添加整形元素
        for (int i = 0; i < list.size(); i++) {
            // 取出集合元素时需要人为的强制类型转化到具体的目标类型
            String element= (String) list.get(i); 
            System.out.println("element:" + element);
        }
    }
}

以上示例在编译阶段是正常的,而运行时会出现“java.lang.ClassCastException”异常。因此,导致此类错误编码过程中不易发现。这时候如果使用泛型就可以使集合能够记住集合内元素各类型,且能够达到只要编译时不出现问题,运行时就不会出现“java.lang.ClassCastException”异常。

泛型的本质是参数化类型,提到参数我们最熟悉的就是定义方法时有形参,然后调用此方法时传递实参。那么参数化类型怎么理解呢?顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。

public class GenericDemo {
    public static void main(String[] args) {
        // 通过List,直接限定了list集合中只能含有String类型的元素
        List list = new ArrayList();
        list.add("zhaowajun"); 
        list.add("generic");
        // list.add(10); // 想加入一个Integer类型的对象时会出现编译错误
        for (int i = 0; i < list.size(); i++) {
            // 无须进行强制类型转换,此时集合能记住元素类型信息,编译器已能够确认它是String类型了
            String element= list.get(i); 
            System.out.println("element:" + element);
        }
    }
}

结合上面的泛型定义,我们知道在List中,String是类型实参,也就是说,相应的List接口中肯定含有类型形参。且get()方法的返回结果也直接是此形参类型(也就是对应的传入的类型实参)。下面来看看List接口的的具体定义:

public interface List extends Collection {
    int size();
    boolean isEmpty();
    boolean contains(Object o);
    Iterator iterator();
    Object[] toArray();
     T[] toArray(T[] a);
    boolean add(E e);
    boolean remove(Object o);
    boolean containsAll(Collection c);
    boolean addAll(Collection c);
    boolean addAll(int index, Collection c);
    boolean removeAll(Collection c);
    boolean retainAll(Collection c);
    void clear();
    boolean equals(Object o);
    int hashCode();
    E get(int index);
    E set(int index, E element);
    void add(int index, E element);
    E remove(int index);
    int indexOf(Object o);
    int lastIndexOf(Object o);
    ListIterator listIterator();
    ListIterator listIterator(int index);
    List subList(int fromIndex, int toIndex);
}

我们可以看到,在List接口中采用泛型化定义之后,中的E表示类型形参,可以接收具体的类型实参,并且此接口定义中,凡是出现E的地方均表示相同的接受自外部的类型实参。自然的,ArrayList作为List接口的实现类,其定义形式是:

public class ArrayList extends AbstractList 
        implements List, RandomAccess, Cloneable, java.io.Serializable {
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }   
    public E get(int index) {
        rangeCheck(index);
        checkForComodification();
        return ArrayList.this.elementData(offset + index);
    }    
    //...省略掉其他具体的定义过程
}

由此,可以解释清楚为什么List类型的集合list中加入Integer类型对象会编译错误,且遍历list元素get()到的类型直接就是String类型了。

 

什么时候使用泛型?

当接口、类及方法中的操作的引用数据类型不确定的时候,以前用的Object来进行扩展的,现在可以用泛型来表示。这样可以避免强转的麻烦,而且将运行问题转移到的编译时期。

 

Java类库中的泛型有哪些?

所有的标准集合接口都是泛型化的—— Collection、List、Set 和 Map。类似地,集合接口的实现都是用相同类型参数泛型化的,所以HashMap 实现 Map 等。

除了集合类之外,Java 类库中还有几个其他的类也充当值的容器。这些类包括 WeakReference、SoftReference 和 ThreadLocal。

 

注意:    

1)对象实例化时不指定泛型,默认为:Object。

2)泛型不同的引用不能相互赋值。

3)加入集合中的对象类型必须与指定的泛型类型一致。

4)静态方法中不能使用类的泛型。

5)如果泛型类是一个接口或抽象类,则不可创建泛型类的对象。

6)不能在catch中使用泛型

7)从泛型类派生子类,泛型类型需具体化

 

 

你可能感兴趣的:(Java-由浅入深的学习之路,Java泛型,泛型概述,Generic)