1.概述
泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,以提高代码的重用率。
下面是一个不使用泛型的例子。
public class GenericDemo01 {
public static void main(String[] args) {
Generic g = new Generic();
g.setInfo(100);
String info = (String)g.getInfo();
System.out.println(info);
}
}
class Generic {
private Object info;
public Object getInfo() {
return info;
}
public void setInfo(Object info) {
this.info = info;
}
}
2.泛型方法
格式:
访问权限 class 类名称<泛型,泛型...>{
属性
方法
}
对象的创建
类名称<具体类型> 对象名称 = new 类名称<具体类型>();
例子:
public class GenericDemo01 {
public static void main(String[] args) {
Generic<String> gen = new Generic<String>();
gen.setInfo("泛型例子");
String info = gen.getInfo();
System.out.println(info);
Generic<Integer> gener = new Generic<Integer>();
gener.setInfo(100);
System.out.println(gener.getInfo());
}
}
class Generic<T> {
private T info;
public T getInfo() {
return info;
}
public void setInfo(T info) {
this.info = info;
}
}
3.构造方法中使用泛型
构造方法可以为类中的属性初始化,那么如果类中的属性通过泛型指定,而又需要通过构造方法设置属性内容的时候,那么构造方法的定义与之前并无不同,不需要像声明类那样指定泛型。
例子:
public class GenericDemo02 {
public static void main(String[] args) {
Cons<String> con = new Cons<String>("构造方法中使用泛型");
System.out.println(con.getValue());
}
}
class Cons<T>{
private T value;
public Cons(T value){
this.value = value;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
4.设置多个泛型
设置多个泛型直接在<>中添加多个泛型就可以了。如<K,T>
例子:
public class GenericDemo03 {
public static void main(String[] args) {
Gen<String,Integer> gen = new Gen<String,Integer>();
gen.setKey("age");
gen.setValue(100);
System.out.println(gen.getKey());
System.out.println(gen.getValue());
}
}
class Gen<K,T>{
private K key;
private T value;
public K getKey() {
return key;
}
public void setKey(K key) {
this.key = key;
}
public T getValue() {
return value;
}
public void setValue(T value) {
this.value = value;
}
}
5.通配符的使用
Generic<Integer>与Generic<Number>实际上是相同的一种基本类型。那么问题来了,在使用Generic<Number>作为形参的方法中,能否使用Generic<Integer>的实例传入呢?在逻辑上类似于Generic<Number>和Generic<Integer>是否可以看成具有父子关系的泛型类型呢?
public class GenericDemo05 {
public static void main(String[] args) {
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
showKey(gInteger);//编译报错
}
public static void showKey(Generic<Number> obj){
System.out.println(obj.getKey());
}
}
class Generic<T>{
private T key;
public Generic(T key){
this.key = key;
}
public T getKey() {
return key;
}
public void setKey(T key) {
this.key = key;
}
}
通过提示信息我们可以看到Generic<Integer>不能被看作为Generic<Number>的子类。由此可以看出:同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
回到上面的例子,如何解决上面的问题?总不能为了定义一个新的方法来处理Generic<Integer>类型的类,这显然与java中的多态理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic<Integer>和Generic<Number>父类的引用类型。由此类型通配符应运而生。
只需要将showKey方法按如下修改
public static void showKey(Generic<?> obj){
System.out.println(obj.getKey());
}
6.泛型接口
在JDK1.5之后,不仅仅可以声明泛型类,也可以声明泛型接口,声明泛型接口和声明泛型类的语法类似,也是在接口名称后面加上<T>格式:
interface 接口名称<泛型标识>{}
例子:
public class GenericDemo05 {
public static void main(String[] args) {
Gin<String> g = new Gin<String>("泛型接口");
g.say();
}
}
interface GenInter<T>{
public void say();
}
class Gin<T> implements GenInter<T>{
private String info;
public Gin(String info){
this.info = info;
}
@Override
public void say() {
System.out.println(info);
}
public String getInfo() {
return info;
}
public void setInfo(String info) {
this.info = info;
}
}
7.泛型方法
在java中,泛型类的定义非常简单,但是泛型方法就比较复杂了。泛型类,是在实例化类的时候指明泛型的具体类型。
泛型方法,是在调用方法的时候指明泛型的具体类型 。
1.泛型方法中可以定义泛型参数,此时,参数的类型就是传入数据类型。
2.格式:
访问权限<泛型标识> 泛型标识 方法名称([泛型标识 参数名称])
public class GenericDemo06 {
public static void main(String[] args) {
Gener gen = new Gener();
String str = gen.tell("泛型方法");
System.out.println(str);
}
}
class Gener{
public <T> T tell(T t){
return t;
}
}
8.泛型上下边界
在使用泛型的时候,我们还可以为传入的泛型类型实参进行上下边界的限制,如:类型实参只准传入某种类型的父类或某种类型的子类。
为泛型添加上边界,即传入的类型实参必须是指定类型的子类型,使用extends关键字。
为泛型添加下边界,即传入的类型实参必须是指定类型或指定类型的父类型,使用super关键字。
泛型上边界例子:
public class GenericDemo07 {
public static void main(String[] args) {
Generics<String> generic1 = new Generics<String>("11111");
Generics<Integer> generic2 = new Generics<Integer>(2222);
Generics<Float> generic3 = new Generics<Float>(2.4f);
Generics<Double> generic4 = new Generics<Double>(2.56);
showKeyValue1(generic1);//编译报错
showKeyValue(generic2);
showKeyValue(generic3);
showKeyValue(generic4);
}
public static void showKeyValue(Generics<? extends Number> obj){
System.out.println(obj.getKey());
}
}
泛型下边界例子:
public class GenericDemo07 {
public static void main(String[] args) {
Generics<Integer> generic2 = new Generics<Integer>(2222);
showKeyValue(generic2);
Generics<Number> generic3 = new Generics<Number>(333);
showKeyValue(generic3);
}
public static void showKeyValue(Generics<? super Integer> obj){
System.out.println(obj.getKey());
}
}
再来一个泛型方法的例子
在泛型方法中添加上下边界限制的时候,必须在权限声明与返回值之间的<T>上添加上下边界,即在泛型声明的时候添加
public <T extends Number> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
T test = container.getKey();
return test;
}
通过上面的两个例子可以看出:泛型的上下边界添加,必须与泛型的声明在一起 。
9.泛型数组
不能创建一个确切的泛型类型的数组
也就是说下面这条语句不支持
List<String>[] ls = new ArrayList<String>[10];
下面使用一个例子来说明这个问题:
List<String>[] lsa = new List<String>[10]; // Not really allowed.
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li;
String s = lsa[1].get(0);
这种情况下,由于JVM泛型的擦除机制,在运行时JVM是不知道泛型信息的,所以可以给oa[1]赋上一个ArrayList而不会出现异常,但是在取出数据的时候却要做一次类型转换,所以就会出现ClassCastException,如果可以进行泛型数组的声明,上面说的这种情况在编译期将不会出现任何的警告和错误,只有在运行时才会出错。而对泛型数组的声明进行限制,对于这样的情况,可以在编译期提示代码有类型安全问题,比没有任何提示要强很多。
数组的类型不可以是类型变量,除非是采用通配符的方式
下面采用通配符的方式是被允许的,因为对于通配符的方式,最后取出数据是要做显式的类型转换的。
List<?>[] lsa = new List<?>[10];
Object o = lsa;
Object[] oa = (Object[]) o;
List<Integer> li = new ArrayList<Integer>();
li.add(new Integer(3));
oa[1] = li;
Integer i = (Integer) lsa[1].get(0);