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类型对象取出

}

}