黑马程序员----java基础之泛性

                               -----------Android培训、java培训、java学习型技术博客、期待与您交流！----------

一、泛型概述

1、泛型：JDK1.5版本以后出现新特性，用于解决安全问题，是一个类型安全机制。
2、好处：
（1）将运行时期出现问题ClassCastException，转移到了编译时期，方便于程序员解决问题，让运行时问题减少，增强了安全性。
（2）避免了强制转换麻烦。
3、泛型格式：通过<>来定义要操作的引用数据类型。
4、泛型种类：泛型可以用于类、方法、静态方法、接口里面。在集合里面使用的泛型其实就是类泛型。
5、泛型术语：ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：
（1）整个称为ArrayList<E>泛型类型
（2）ArrayList<E>中的E称为类型变量或类型参数
（3）整个ArrayList<Integer>称为参数化的类型
（4）ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数
（5）ArrayList<Integer>中的<>念着typeof
（6）ArrayList称为原始类型
6、参数化类型与原始类型的兼容性：
参数化类型可以引用一个原始类型的对象，编译报告警告，例如，Collection<String> c = new Vector();//可不可以，不就是编译器一句话的事吗？
原始类型可以引用一个参数化类型的对象，编译报告警告，例如，Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能传进去
7、参数化类型不考虑类型参数的继承关系：
Vector<String> v = new Vector<Object>(); //错误!///不写<Object>没错，写了就是明知故犯
Vector<Object> v = new Vector<String>(); //也错误!
8、编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

Vector<Integer> vectorList[] = newVector<Integer>[10];

二、泛型的基本用法
1、泛型类：什么时候定义泛型类？当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。

class Worker {  
  
}  
  
class Utils<T> {  
    private T q;  
  
    public void setObject(T q) {  
        this.q = q;  
    }  
  
    public T getObject() {  
        return q;  
    }  
}  
  
class GenericDemo3 {  
    public static void main(String[] args) {  
        Utils<Worker> u = new Utils<Worker>();  
    }  
}  

2、泛型方法

class Demo<T> {  
    public void show(T t) {  
        System.out.println("show:" + t);  
    }  
  
    public <Q> void print(Q q) {  
        System.out.println("print:" + q);  
    }  
  
    public static <W> void method(W t) {  
        System.out.println("method:" + t);  
    }  
}  
  
class GenericDemo4 {  
    public static void main(String[] args) {  
        Demo<String> d = new Demo<String>();  
        d.show("haha");  
        // d.show(4);  
        d.print(5);  
        d.print("hehe");  
        Demo.method("hahahahha");  
    }  
}  

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。特殊之处：静态方法不可以访问类上定义的泛型。如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

3、泛型接口

interface Inter<T> {  
    void show(T t);  
}  
  
class InterImpl<T> implements Inter<T> {  
    public void show(T t) {  
        System.out.println("show :" + t);  
    }  
}  
  
class GenericDemo5 {  
    public static void main(String[] args) {  
        InterImpl<Integer> i = new InterImpl<Integer>();  
        i.show(4);  
    }  
}  

4、通配符及泛型界定

（1）定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？

public static void printCollection(Collection<?> cols) {  
        for(Object obj:cols) {  
            System.out.println(obj);  
        }  
}

（2）泛型限定
1）限定通配符的上边界：
正确：Vector<? extends Number> x = new Vector<Integer>();
错误：Vector<? extends Number> x = new Vector<String>();
2）限定通配符的下边界：
正确：Vector<? super Integer> x = new Vector<Number>();
错误：Vector<? super Integer> x = new Vector<Byte>();
注意：限定通配符包括自己。？通配符只能用作引用，不能给其变量赋值，因为不知道其类型。

三、泛型原理

1、泛型的原理：泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。
2、类型的推断：编译器判断范型方法的实际类型参数的过程称为类型推断，类型推断是相对于知觉推断的，其实现方法是一种非常复杂的过程。

3、泛型与反射：通过反射机制可以向使用泛型的集合里面添加其他类型的元素，代码如下：

                ArrayList<Integer> collection = new ArrayList<Integer>();
		collection.getClass().getMethod("add", Object.class).invoke(collection, "abc");

四、泛型相关

1、jdk源码中如List接口，用来抽取一些基本的操作。
2、在反射的应用里面经常用到泛型。
3、java api里面集合的应用。
4、封装基类的时候，如Android开发中自己写的orm小框架以及PullToRefresh框架等等。