黑马程序员 知识点总结-Java泛型



----------------------Android培训、Java培训、期待与您交流！ ----------------------

【泛型入门】

      泛型是jdk1.5的新特性，也是最难深入掌握的部分。

      使用泛型集合，可以将一个集合中的元素限定为一个特定的类型，集合中只能存储同一种类型对象，这样更安全，并且当从集合中获取对象时，编译器也知道这个的对象的类型，不需要对对象进行强制类型转换，更加方便。

      如：

// 定义用于存储Integer类型数据的集合ArrayList<Integer> al1 = new ArrayList<Integer>();// al.add("abc");编译无法通过// al.add(true);al1.add(1);

      泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编一起挡住源程序中的非法输入。编译器编译带类型说明的集合时会去除掉“类型”的信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原是类型完全一致。由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

      如：

// 定义用于存储String类型数据的集合ArrayList<String> al2 = new ArrayList<String>();// 判断两个集合的Class实例对象是否相等System.out.println(al1.getClass() == al2.getClass());// true// 利用反射得到集合再调用add方法可往集合中添加其他类型的数据try {System.out.println(al2.getClass().getMethod("add", Object.class).invoke(al2, true));} catch (Exception e) {e.printStackTrace();}

【了解泛型】

泛型的相关术语(以ArrayLiet<E>类定义和ArrayLIst<Integer>类引用为例)

1. 整个称为ArrayLiet<E>泛型类型

2. ArrayLiet<E>中的E成为类型变量或类型参数

3. ArrayLIst<Integer>中的Integer成为类型参数的实例或实例参数类型

4. ArrayLIst<Integer>中的<>念typeof

5. ArrayList称为原始类型

   参数化类型和原始类型的兼容性

   参数化类型可以引用一个原始类型的对象，但编译报告警告。如：

   Collection<String> c = new Vector();

   原始类型可以引用一个参数化类型的对象，但编译报告警告。如：

   Collection c = new Vsctor<String>();

   参数化类型不考虑类型参数的继承关系

   Vector<String> v = newVector<Object>();//错误

          假设可以的话，那么以后从v取出的对象当作String用，而v实际上指向的集合中可以添加任意类型的对象。

   Vector<Object> v = new Vector<String>();//错误

          假设可以的话，那么以后可以向v中加入任意类型的对象，而v实际上指向的集合中只能装String类型的对象。

   在创建数组实例时，数组的元素不能使用参数化的类型

   Vector<Integer> vectorList[] = newVector<Integer>[10];//错误

   思考题：以下代码是否会报错？

   Vector v1 =newVector<String>();

   Vector<Object>v = v1;

   不会报错，因为Vector v1 = newVector<String>();是原始类型引用一个参数化类型的对象，而Vector<Object> v = v1;是参数化类型引用一个原始类型的对象。

   【泛型通配符及其扩展应用】

          ?：通配符，占位符，当要操作的引用数据类型不明确时，可用该符号代替

          使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作与引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

          如：

public static void print(Collection<?> col) {// add()方法中添元素的类型应该与col集合的类型相同，// 而col的类型与传递进来的参数有关，不一定就是String// 所以会可能发生类型不匹配，所以会报错// col.add("abc");// 集合中的元素都是Object的子类，所以没错for (Object obj : col) {System.out.println(obj);}// size()方法类型参数没有关系，所以没错System.out.println(col.size());}

   通配符的限定

1. 向上限定，即限定通配符的上边界? extends E：可以接收E类型或者E的子类型Vector<? extends Number> v = newVector<Integer>();

   Vector<? extendsNumber> v = new Vector<String>();

   第一个是正确的，因为Integer是Number的子类，而第二个是错误的，因为String不是Number的子类

2. 向下限定，即限定通配符的下边界? super E：可以接收E类型或者E的父类型

   Vector<? superInteger> v = new Vector<Number>();

   Vector<? superInteger> v = new Vector<Byte>();

   第一个是正确的，因为Number是Integer的父类，而第二个是错误的，因为Byte不是Integer的父类

   【自定义泛型及其引用】

   自定义泛型方法

   [访问权限修饰符] [static][final] <类型参数列表>返回值类型方法名([形式参数列表])

   如：

// 定义泛型方法，实现数组元素位置交换public static <T> void swap(T[] arr, int x, int y) {T temp = arr[x];arr[x] = arr[y];arr[y] = temp;}

1. 用于放置类型参数的尖括号应出现在方法的其他修饰符之后，返回值类型之前，并且类型参数通常用单个大写字母表示。

2. 只有引用类型才能作为方法的实际参数，如使用上例的方法swap(new int[3],1,2);程序会报错。

3. 除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如Class.getAnnotation方法的定义，并且可以用&限定多个边界，如<V extends Serializable & Cloneable> void method(){}

4. 普通方法，构造方法，静态方法都可以使用泛型

5. 也可以用类型变量表示异常，称为参数化异常，可以用于方法的throws列表中，但不能用于catch子句中。

public static <T extends Exception> void sayHello() throws T {try {} catch (Exception e) {throw (T) e;}}

6、 在泛型中可以同时有多个类型参数，在定义它们的尖括号中用逗号隔开，例如

public static <K,V> V getValue(Kkey){return map.get(key);}

类型参数的类型推断

      编译器判断泛型方法的实际类型参数的过程叫做类型推断，其实现方法是一种非常复杂

 的过程。

根据调用泛型方法时实际传递的类型参数或返回值的类型来推断，具体规则如下：

Ø      当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

                           swap(new String[3],3,4)  à   static <E> void swap(E[] a, int i, int j)

Ø      当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：

                           add(3,5)  à static <T> T add(T a, T b)

Ø      当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，且没有使用返回值，这时候取多个参数中的最大交集类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

                         fill(new Integer[3],3.5f)  à static <T> void fill(T[] a, T v)

Ø      当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型对应到了不同的类型，并且使用返回值，这时候优先考虑返回值的类型，例如，下面语句实际对应的类型就是Integer了，编译将报告错误，将变量x的类型改为float，对比eclipse报告的错误提示，接着再将变量x类型改为Number，则没有了错误：

                           int x =(3,3.5f)  àstatic <T> T add(T a, T b)

Ø      参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没有问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

                          copy(newInteger[5],new String[5])à static <T> void copy(T[]a,T[] b);

                          copy(newVector<String>(), new Integer[5])

àstatic <T> void copy(Collection<T> a , T[] b);

自定义泛型类

      如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保

 持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型。

 语法格式如例：

public class GenericDao<T> {private T field;public void add(T obj){}public T getById(int id){}public void update(T obj){}…}

      类级别的泛型是根据引用该类名时指定的类型信息来参数化类型变量的，例如，如下两

 种方式都可以：

      1、GenericDao<String>dao =null;

   2、new GenericDao<String>();

      注意：

• 泛型类定义的泛型，在整个类中都有效，如果被方法使用，那么当泛型类的对象明确了要操作的具体类型后，该方法所要操作的类型也就固定了

• 在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能是基本类型。

• 当一个变量被声明为泛型时，只能被实例变量、方法和内部类调用，而不能被静态变量和静态方法调用。因为静态成员是被所有参数化的类所共享的，所以静态成员不应该有类级别的类型参数。

【泛型接口】

    格式：访问修饰符 interface 接口名<类型参数列表>

如：

interface Inter<T> {public void show(T t);}

泛型接口的实现：

interface Inter<T> {public void show(T t);}// 泛型接口实现方式一：指定泛型接口要操作的引用数据类型class InterImpl1 implements Inter<String> {public void show(String s) {System.out.println(s);}}// 泛型接口实现方式二：不指定泛型接口要操作的引用数据类型class InterImpl2<T> implements Inter<T> {public void show(T t) {System.out.println(t);}}class GenericDemo04 {public static void main(String[] args) {InterImpl1 it1 = new InterImpl1();it1.show("hellojava");InterImpl2<String> it2 = new InterImpl2<String>();it2.show("helloworld");}}

【通过反射获取泛型的实际类型参数】

      示例代码：

import java.lang.reflect.Method;import java.lang.reflect.ParameterizedType;import java.lang.reflect.Type;import java.util.ArrayList;public class GenericTest {public static void main(String[] args) {ArrayList<String> al = new ArrayList<String>();try {// 获取applyArrayList方法的Method类对象Method applyMethod = GenericTest.class.getMethod("applyArrayList",ArrayList.class);// getGenericParameterTypes()方法返回Type 对象的数组，// 这些对象描述了此 Method 对象所表示的方法的形参类型的。Type[] types = applyMethod.getGenericParameterTypes();// ParameterizedType 表示参数化类型，如 Collection<String>。ParameterizedType pType = (ParameterizedType) types[0];// getRawType()方法返回原始类型System.out.println(pType.getRawType());// getActualTypeArguments()返回表示此类型实际类型参数的 Type// 对象的数组。类型参数可能有多个，如Map<K,V>，是所以返回的是数组System.out.println(pType.getActualTypeArguments()[0]);} catch (Exception e) {e.printStackTrace();}}// 定义方法，参数为要获取的泛型实际类型参数的对象public static void applyArrayList(ArrayList<String> al) {}}

----------------------Android培训、Java培训、期待与您交流！ ----------------------