1. 泛型的简单运 用和意义

2. 泛型的上限与下限

3. 泛型和 子类继承的限制

4. 泛型类和泛型 方法

5. 泛型嵌套和泛型擦除

泛型(Generic)

什 么是泛型:

•java5开始出现的 一种对Java语 言类型的 一种拓 展,以 支持创建可以按类型进 行 参数化的类.可以把类型参数看作是使 用参数类型时指定的类型占位符,就好 比 方法的形式参数是实际参数的占位符 一样.

•泛型能保证 大型应 用程序的类型安全和良好的维护性;使 用泛型的优势:

•类型安全,使编译器 对泛型定义的类型做判断限制.如保证TreeSet 里 的元素类型

必须 一致;

•消除强制类型的转换,如,使 用Comparable 比较时每次都需要类型强转;

泛型类

在类声明时通过 一个标识符表示类中某个字段的类型或者某个 方法的返回值或参数的类型，这样在类声明或实例 化的时候只要指定 自 己需要的类型就ok。

声明带泛型的类: class 类名<泛型类型1,泛型类型2……>{

泛型类型 变量 名；泛型类型  方法名(){}

返回值类型  方法名(泛型类型 变量 名){}

}

使 用带泛型的类：

类名<具体类> 对象名 = new 类名<具体类>();

注意：

类型参数规范：推荐使 用规范-常 见的泛型,泛型只保存在源 文件中,class 文件中不 存在;也就是说在编译阶段就会丢失,基本数据类型不 能作为泛型类型;

K 键， 比如映射的键 key的类型

V  值， 比如Map的值 value类型

E  元素， 比如Set<E>  Element表示元素,元素的类型

T 泛型，Type的意思

思考List<Object> l   和 List<String> l 是否可以运 行

通配符

在进 行 引 用传递的时候泛型类型必须匹配才可以传递，否则编译不 通过；使 用 ？ ，表示未知类型的泛型对象：

•List<?> 表示未知元素的List集合；

•这种带通配符的List仅表示各种泛型List的 父类，并不 能把元素添加 入集合中；

•List<?> list = new ArrayList<>(); list.add(1);//ERROR 编译器  无法基于信息作类型推断

public void show(List<?> list){}

•//表示可接受任意类型的List集合

泛型的上限与下限

设置泛型对象的上限使 用extends,表示参数类型只能是该类型或该类型的 子类：

•声明对象：类名<? extends 类> 对象名

•定义类：类名<泛型标签 extends 类>{}

设置泛型对象的下限使 用super,表示参数类型只能是该类型或该类型的 父类：

•声明对象：类名<? super 类> 对象名称

•定义类：类名<泛型标签 extends类>{}

public static void  show(List<? extends Number> l){}public static void  show(List<? super String> l){}public static void main(String[] args) { Person<Integer> p1 = new Person<>(); p1.setVal(99);Person<Double> p2 = new Person<>(); p2.setVal(3.14);Person<String> p3 = new Person<>(); p3.setVal("007");show(p1);//√ show(p2);//√ show(p3);//×

}public static void show(Person<? extends Number> p){ System.out.println(p.getVal());}public static void main(String[] args) { Person<Integer> p1 = new Person<>(); p1.setVal(99);//Integer Person<Double> p2 = new Person<>(); p2.setVal(3.14);//Double

Person<String> p3 = new Person<>(); p3.setVal("007");//String Person<Object> p4 = new Person<>(); p4.setVal(new Object());//Object show(p1);//×

show(p2);//× show(p3);//√ show(p4);//√

}public static void show(Person<? super String> p){ System.out.println(p.getVal());}

泛型接 口

java5后，可以声明泛型接 口，声明 方式和声明泛型类是 一样的。

•public interface IDAO<T>{}

泛型接 口 子类有两种 方式：

•直接在 子类后申明泛型；

•在 子类实现的接 口中给出具体的泛型类型

public class DaoImpl<T> implements IDAO<T>{}public class DaoImpl implements IDAO<String> {}

泛型 方法

方法中可定义泛型参数，形参的参数类型就是实参的类型。格式：

•<泛型标签> 返回值类型  方法名([泛型标签 参数]...)

public static <T> T show(T param){ return param;
}.....main.....{ System.out.println(show(new Date())); System.out.println(show("cditcast"));}

泛型使 用

通过泛型 方法返回泛型对象

•此时必须在 方法返回类型处明确给出具体类型统 一传 入的参数类型泛型数组

public <T> T[] show(T[] ts) {}public <T> void show(T ... ts){}

泛型的嵌套

可以从 一个类的泛型中指向另 一个类的泛型：

public class Demo1 {public static void main(String[] args) { 　　　　Map<String,String> map = new HashMap<>(); map.put("1", "A");map.put("2", "B"); map.put("3", "C"); map.put("4", "D");Set<Map.Entry<String, String>> set = map.entrySet(); Iterator<Map.Entry<String, String>> it = set.iterator(); while(it.hasNext()) {Map.Entry<String, String> entry = it.next(); System.out.println(entry.getKey() +"-->" + entry.getValue());}}}

泛型的擦除

在严格的泛型代码 里 ，带泛型声明的类总应该带着类型参数。但是为了 和 老 的Java代码保持 一致，也允许在使 用带泛型声明的类时不 指定类型参数，若没有为这个泛型类指定类型参数则该类型参数被称做 一个原始类型，默认是该声明参数时指定的最上限类型；

当把 一个具有泛型信息的对象赋给另 一个没有泛型信息的变量 时，则所有在尖括号之间的类型信息都被扔掉。

• 比如List<String> 类型转换成List，则该List对集合元素的类型检查变成了 变量 的上限即Object。

泛型的擦除和转换

class Num<T extends Number>{private T t;public Num(T t) {this.t= t;}//。。。。 getter/setter。。。。
}
public class Demo{public static void main(String[] args) {Num<Integer> n= new Num<>(5);Integer i= n.getT();Num n2 = n;//会丢掉泛型信息Number num= n2.getT();//Integer i= n2.getT();}
}
public class Demo{public static void main(String[] args) {List<Integer> li= new ArrayList<>();li.add(1);List<String> ls= null;//ls= li;不能转换List list= li;ls= list;//不会报错,只有未经检查警告,此时l ist实际引用的是List<Integer>System.out.println("-->" + ls.get(0));//企图当做String类型对象取出}
}