所谓泛型:就是允许在定义类、接口是指丁类型形参,这个类型形参将在生命变量、创建对象时确定(即传入实际的类型参数)。包含泛型声明的类型可以在定义变量、创建对象时传入以各类型实参,从而可以动态生成无数多个逻辑上的子类,但这种兹雷在物理上并不存在。可以为任何类增加泛型声明
//定义Apple类时使用了泛型声明
public class Apple<T>
{
//使用T类型形参定义属性
private T info;
public Apple(){}
//下面方法中使用T类型形参来定义方法
public Apple(T info)
{
this.info = info;
}
public void setInfo(T info)
{
this.info = info;
}
public T getInfo()
{
return this.info;
}
public static void main(String[] args)
{
//因为传给T形参的是String实际类型,所以构造器的参数只能是String
Apple<String> a1 = new Apple<String>("苹果");
System.out.println(a1.getInfo());
//因为传给T形参的是Double实际类型,所以构造器的参数只能是Double或者double
Apple<Double> a2 = new Apple<Double>(5.67);
System.out.println(a2.getInfo());
}
}
实际使用Apple<T>类型时会为T形参传入实际类型,可以生成入Apple<String>,Apple<Double>...物理上并不存在。
从泛型类派生子类
当创建了带泛型声明的接口、父类之后,可以为该接口创建实现类,或从该父类来派生子类,当使用这些接口、父类是不能再包含类型形参,如下面是错误的
//定义A继承Apple类,Apple类不能跟类型形参
public class A extends Apple<T>{}
//使用Apple类时为T形参传入String类型
public class A extends Apple<String>
使用方法是必须为所有的数据形参传入参数值,与使用方法不同的是:使用类、接口是可以不为类型形参传入实际的类型,如下
//使用Apple类时,没有为T形参传入实际的类型参数
public class A extends Apple
如果从Apple<String>类派生子类,则在Apple类中所有使用T类型的地方都将被替换成String类型,即它的子类型将汇继承到String getInfo()和void setInfo(String info)两个方法,如果子类需要重写父类的方法,必须注意这一点。
public class A1 extends Apple<String>
{
//正确重写了父类的方法,返回值与父类Apple<String>的返回值完全相同
public String getInfo()
{
return "子类" + super.getInfo();
}
/*
//下面方法是错误的,重写父类方法时返回值类型不一致
public Object getInfo()
{
return "子类";
}
*/
}
类型通配符
public class Test
{
public void test(List<Object> c) //
{
for (int i = 0; i < c.size(); i++)
{
System.out.println(c.get(i));
}
}
public static void main(String[] args)
{
List<String> strList = new ArrayList<String>();
Test t = new Test();
t.test(strList);
}
}
Java泛型的好处是安全简单。
在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
Java泛型在使用中还有一些规则和限制:
1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句,例如
。习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class
classType = Class.forName(java.lang.String);
泛型还有接口、方法等等,内容很多,需要花费一番功夫才能理解掌握并熟练应用。在此给出我曾经了解泛型时候写出的两个例子(根据看的印象写的),实现同样的功能,一个使用了泛型,一个没有使用,通过对比,可以很快学会泛型的应用,学会这个基本上学会了泛型70%的内容。
例子一:使用了Java泛型
public class Gen
{
private T ob; //定义泛型成员变量 public Gen(T ob) { this.ob = ob; } public T getOb() { return ob; } public void setOb(T ob) { this.ob = ob; } public void showTyep() { System.out.println("T的实际类型是: " + ob.getClass().getName()); } } public class GenDemo { public static void main(String[] args){ //定义泛型类Gen的一个Integer版本 Gen intOb=new Gen (88); intOb.showTyep(); int i= intOb.getOb(); System.out.println("value= " + i); System.out.println("----------------------------------"); //定义泛型类Gen的一个String版本 Gen strOb=new Gen ("Hello Gen!"); strOb.showTyep(); String s=strOb.getOb(); System.out.println("value= " + s); } } |
例子二:没有使用Java泛型
public class Gen2 { private Object ob; //定义一个通用类型成员 public Gen2(Object ob) { this.ob = ob; } public Object getOb() { return ob; } public void setOb(Object ob) { this.ob = ob; } public void showTyep() { System.out.println("T的实际类型是: " + ob.getClass().getName()); } } public class GenDemo2 { public static void main(String[] args) { //定义类Gen2的一个Integer版本 Gen2 intOb = new Gen2(new Integer(88)); intOb.showTyep(); int i = (Integer) intOb.getOb(); System.out.println("value= " + i); System.out.println("----------------------------------"); //定义类Gen2的一个String版本 Gen2 strOb = new Gen2("Hello Gen!"); strOb.showTyep(); String s = (String) strOb.getOb(); System.out.println("value= " + s); } } |
运行结果:
两个例子运行Demo结果是相同的,控制台输出结果如下:
T的实际类型是:
java.lang.Integer value= 88 ---------------------------------- T的实际类型是: java.lang.String value= Hello Gen! Process finished with exit code 0 |