Java泛型:
泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动的或者隐式的,提高代码的重用性。
规则:
- 泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。(注意类型参数只能代表引用型类型,不能是原始类型(像int,double,char的等)。)
2、每一个类型参数声明部分包含一个或多个类型参数,参数间用逗号隔开。一个泛型参数,也被称为一个类型变量,是用于指定一个泛型类型名称的标识符。
4、泛型的参数类型可以使用extends语句,例如<T extends superclass>。习惯上称为“有界类型”。
5、泛型的参数类型可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");
6、所有泛型方法声明都有一个类型参数声明部分(由尖括号分隔),该类型参数声明部分在方法返回类型之前(在下面例子中的<E>)。public <T> void show(T x) {
class Fanx<T>{ private T data; public Fanx(T data) { this.data=data; } public T getData() { return data; } public void setData(T data) { this.data = data; } public void showType() { System.out.println("T: " + data.getClass().getName()+" data:"+this.data); } } public class Main { public static void main(String [] args) { Fanx<Integer> fanx=new Fanx<Integer>(100); fanx.showType(); Fanx<String> fanx2=new Fanx<String>("hello"); fanx2.showType(); } } | 输出结果: T: java.lang.Integer data:100 T: java.lang.String data:hello |
- class GenericsF<T> 声明了一个泛型类,这个T没有任何限制,实际上相当于Object类型,实际上相当于 class GenericsF<T extends Object>。
- 与Object泛型类相比,使用泛型了锁定义的类在声明和构造函数的时候,可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如GenericsF<Double> douF=new GenericsF<Double>(new Double("33"));
- 也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型,但是你在使用该对象的时候,就需要强制转换了。比如:GenericsF douF=new GenericsF(new Double("33"));
限制泛型
在上面的例子中,由于没有限制class GenericsF<T>类型持有者T的范围,实际上这里的限定类型相当于Object,这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做:
class GenericsF<T extends Collection>,这样类中的泛型T只能是Collection接口的实现类,传入非Collection接口编译会出错。
注意:<T extends Collection>这里的限定使用关键字extends,后面可以是(collection)类也可以是接口。但这里的extends已经不是继承的含义了,应该理解为T类型是实现Collection接口的类型,或者T是继承了XX类的类型。
public class CollectionGenFoo<T extends Collection> { private T x; public CollectionGenFoo(T x) { this.x = x; } public T getX() { return x; } public void setX(T x) { this.x = x; } } | public class Main{ public static void main(String args[]) { CollectionGenFoo<ArrayList> listFoo = null; listFoo = new CollectionGenFoo<ArrayList>(new ArrayList()); System.out.println("实例化成功!"); } }
|
|
多接口限制:
<T extends SomeClass & interface1 & interface2 >
public class Demo<T extends Comparable & Serializable> {
// T类型就可以用Comparable声明的方法和Seriablizable所拥有的特性了
}
泛型方法
是否拥有泛型方法,与其所在的类是否泛型没有关系。要定义泛型方法,只需将泛型参数列表置于返回值前
public class A{ public <T> void show(T x) { System.out.println(x.getClass().getName()+": "+x); } public static void main(String[] args) { A a=new A(); a.show("hello"); a.show('a'); a.show(3); a.show(a); } } |
输出结果: java.lang.String: hello java.lang.Character: a java.lang.Integer: 3 aaa.A: aaa.A@7852e922 |
java泛型中<?>和<T>区别
public class A{ public static void printColl(ArrayList<?> al){ Iterator<?> it = al.iterator(); while(it.hasNext()) { System.out.print(it.next().toString()); } } public static void main(String[] args) { ArrayList<Integer> arr=new ArrayList<>(); arr.add(1);arr.add(2);arr.add(3); printColl(arr); ArrayList<Character> acc=new ArrayList<>(); acc.add('a');acc.add('b');acc.add('c'); printColl(acc); } } | 输出结果:123abc
T自定义泛型和?通配符泛型
?和T都表示不确定的类型 但如果是T的话 函数里面可以对T进行操作 比如while里面可以这样写 |
加了泛型了参数不能调用与参数类型有关的方法比如“+”;如打印出任意参数化类型集合中的所有内容,就适合用通配符泛型<?>
public static void printCollecton(Collection <?> collection)
{
for(Object obj: collection)
{
System.out.println(obj);
}
}
泛型三种:
ArrayList<T> al=new ArrayList<T>();指定集合元素只能是T类型
ArrayList<?> al=new ArrayList<?>();集合元素可以是任意类型,这种没有意义,一般是方法中,只是为了说明用法
ArrayList<? extends E> al=new ArrayList<? extends E>();
泛型的限定:
? extends E:接收E类型或者E的子类型。
?super E:接收E类型或者E的父类型。