什么是泛型
泛型,即“参数化类型”,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。泛型的本质是为了参数化类型(在不创建新的类型的情况下,通过泛型指定的不同类型来控制形参具体限制的类型)。也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。
使用泛型的好处
- 代码更加简洁【不用强制转换】
- 程序更加健壮【只要编译时期没有警告,那么运行时期就不会出现ClassCastException异常】
- 可读性和稳定性【在编写集合的时候,就限定了类型】
泛型类
泛型类就是把泛型定义在类上,使用该类的时候,才把类型明确下来
//定义
class 类名<泛型类型标识>{
}
//应用
类名<具体类> 对象名 = new 类名<具体类> ();
//在实例化泛型类时,必须指定T的具体类型
public class Point<T>{ //类型参数:通常用一个大写字母表示。多个类型参数用逗号分隔T,E,V,K
private T x;//
private T y;
public T getX() {
return x;
}
public void setX(T x) {
this.x = x;
}
public T getY() {
return y;
}
public void setY(T y) {
this.y = y;
}
}
当对泛型进行实例化的时候,同一个泛型类实例化出的对象getClass之后是相同的
//实例化时给出的是什么类型存放数据时就必须是什么类型
Point<Integer> p1 = new Point<>();
p1.setX(11); // int -> Integer -> Object
p1.setY(22);
Point<Double> p2 = new Point<>();
p2.setX(11.1);// double -> Double -> Object
p2.setY(22.2);
Point<String> p3 = new Point<>();
p3.setX("11.1");// String -> Object
p3.setY("22.2");
// 几个泛型类?一个泛型类
System.out.println(p1.getClass() == p2.getClass());
System.out.println(p1.getClass() == p3.getClass());
System.out.println(p2.getClass() == p3.getClass());
//以上输出均为true
之所以相同是因为Java在编译期间,所有的泛型信息都会被擦掉,Java的泛型基本上都是在编译器这个层次上实现的,在生成的字节码中是不包含泛型中的类型信息的,使用泛型的时候加上类型参数,在编译器编译的时候会去掉,这个过程称为类型擦除。
参数化类型:一个类型后边指定一个具体类型参数。
Point<Integer>
原生类型:一个类型后边没有指定具体的类型参数。
Point p2 ;
通配符
当泛型类对象作为参数被方法调用时,如果想调用不同类型参数的泛型对象,就要用到通配符
注意:泛型中的< Object >并不是像以前那样有继承关系的,也就是说List< Object >和List< String >是毫无关系的!!!!
- ? 无界通配符 匹配 所有的引用类型
- ?extends 上限类 匹配 上限类 和 上限类的子类型
- ? super 下限类 匹配 下限类和 下限类的父类
//所有类型都能用
public void showPoint(Point<?> p){// 应用
System.out.println(p.getX() + ":" + p.getY());
}
// 集合装载的元素只能是Number的子类或自身
public void showPoint(Point<? extends Number> p){// 应用
System.out.println(p.getX() + ":" + p.getY());
}
//传递进来的只能是Number或Number的父类
public void showPoint(Point<? super Number> p){// 应用
System.out.println("p.getX() + ":" + p.getY());
}
泛型方法
泛型类,是在实例化类的时候指明泛型的具体类型;泛型方法,是在调用方法的时候指明泛型的具体类型 。
如果我们仅仅在某一个方法上需要使用泛型,只关心该方法,而不关心类其他的属性,这样的话,我们就不必在整个类上定义泛型
//定义泛型方法..
/*
说明:
* 1)public与返回值中间<T>非常重要,可以理解为声明此方法为泛型方法。
* 2)只有声明了<T>的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
* 3)<T>表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
* 4)与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型。
*/
public <T> T show(T t) {//有返回值,类型为T
// public <T> void show(T t){无返回值
System.out.println(t);
return t;
}
泛型类中的泛型方法
public class GenericFruit {
class Fruit{
@Override
public String toString() {
return "fruit";
}
}
class Apple extends Fruit{
@Override
public String toString() {
return "apple";
}
}
class Person{
@Override
public String toString() {
return "Person";
}
}
class GenerateTest<T>{
public void show_1(T t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法,使用泛型E,这种泛型E可以为任意类型。可以类型与T相同,也可以不同。
//由于泛型方法在声明的时候会声明泛型<E>,因此即使在泛型类中并未声明泛型,编译器也能够正确识别泛型方法中识别的泛型。
public <E> void show_3(E t){
System.out.println(t.toString());
}
//在泛型类中声明了一个泛型方法,使用泛型T,注意这个T是一种全新的类型,可以与泛型类中声明的T不是同一种类型。
public <T> void show_2(T t){
System.out.println(t.toString());
}
}
public static void main(String[] args) {
Apple apple = new Apple();
Person person = new Person();
GenerateTest<Fruit> generateTest = new GenerateTest<Fruit>();
//apple是Fruit的子类,所以这里可以
generateTest.show_1(apple);
//编译器会报错,因为泛型类型实参指定的是Fruit,而传入的实参类是Person
//generateTest.show_1(person);
//使用这两个方法都可以成功
generateTest.show_2(apple);
generateTest.show_2(person);
//使用这两个方法也都可以成功
generateTest.show_3(apple);
generateTest.show_3(person);
}
}
静态方法与泛型
如果一个静态方法要使用泛型的话,这个静态方法也必须声明为泛型方法,单纯的静态方法无法访问类上定义的泛型,
public static <T> void show(T t)
泛型类派生出的子类
泛型类是拥有泛型这个特性的类,它本质上还是一个Java类,那么它就可以被继承
在被继承的时候分两种情况:
- 子类明确泛型类的类型参数变量
- 子类不明确泛型类的类型参数变量
子类明确泛型类的类型参数变量
- 泛型接口
/*
把泛型定义在接口上
*/
public interface Inter<T> {
public abstract void show(T t);
}
/**
* 子类明确泛型类的类型参数变量:
*/
public class InterImpl implements Inter<String> {
@Override
public void show(String s) {
System.out.println(s);
}
}
- 子类不明确泛型类的类型参数变量
当子类不明确泛型类的类型参数变量时,外界使用子类的时候,也需要传递类型参数变量进来,在实现类上需要定义出类型参数变量
/**
* 子类不明确泛型类的类型参数变量:
* 实现类也要定义出<T>类型的
*
*/
public class InterImpl<T> implements Inter<T> {
@Override
public void show(T t) {
System.out.println(t);
}
}