Java中泛型的标记符的含义:
E-Element(在集合中使用,因为集合中存放的是元素)
T-Type(Java类)
K-Key(键)
N-Number(数值类型)
V-Value(值)
?-表示不确定的java类型
ArrayList<? extends E> al=new ArrayList<? extends E>();
泛型的限定:
? extends E:接收E类型或者E的子类型。
? super E:接收E类型或者E的父类型
- Object和T不同点在于,Object是一个实打实的类,并没有泛指谁,而T可以泛指Object,比方public void printList(List<T> list){}方法中可以传入List<Object> list类型参数,也可以传入List<String> list类型参数,但是public void printList(List<Object> list){}就只可以传入List<Object> list类型参数,因为Object类型并没有泛指谁,是一个确定的类型
- ?和T区别是?是一个不确定类,?和T都表示不确定的类型 ,但如果是T的话,函数里面可以对T进行操作,比方 T car = getCar(),而不能用? car = getCar()。
下面举个栗子比较下这三种:
package com.lyang.demo.fanxing;
import java.util.Arrays;
import java.util.List;
/**
* 测试泛型参数Object和T的区别
* Created by yanglu on 2017/04/20.
*/
public class TestDifferenceBetweenObjectAndT {
public static void printList1(List<Object> list) {
for (Object elem : list)
System.out.println(elem + " ");
System.out.println();
}
public static <T> void printList2(List<T> list) {
for (T elem : list)
System.out.println(elem + " ");
System.out.println();
}
public static void printList3(List<?> list) {
for (int i = 0;i<list.size();i++)
System.out.println(list.get(i) + " ");
System.out.println();
}
public static void main(String[] args) {
List<Integer> test1 = Arrays.asList(1, 2, 3);
List<String> test2 = Arrays.asList("one", "two", "three");
List<Object> test3 = Arrays.asList(1, "two", 1.23);
List<Fruit> test4 = Arrays.asList(new Apple(), new Banana());
/*
* 下面这句会编译报错,因为参数不能转化成功
* */
printList1(test4);
/**/
printList1(test3);
printList1(test3);
printList2(test1);
printList2(test2);
printList2(test3);
printList3(test1);
printList3(test2);
printList3(test3);
}
}
如何获取到Class类呢,有三种方式:
1. 调用Object类的getClass()方法来得到Class对象,这也是最常见的产生Class对象的方法。
例如:
List list = null;
Class clazz = list.getClass();
**2. 使用Class类的中静态forName()方法获得与字符串对应的Class对象。
**
例如:
Class clazz = Class.forName("com.lyang.demo.fanxing.People");
3.获取Class类型对象的第三个方法非常简单。如果T是一个Java类型,那么T.class就代表了匹配的类对象。
Class clazz = List.class;
** 那么问题来了?Class类是创建出来了,但是Class<T>和Class<?>适用于什么时候呢???**
使用Class<T>和Class<?>多发生在反射场景下,先看看如果我们不使用泛型,反射创建一个类是什么样的。
People people = (People) Class.forName("com.lyang.demo.fanxing.People").newInstance();
看到了么,需要强转,如果反射的类型不是People类,就会报
java.lang.ClassCastException错误。
使用Class<T>泛型后,不用强转了
public class Test {
public static <T> T createInstance(Class<T> clazz) throws IllegalAccessException, InstantiationException {
return clazz.newInstance();
}
public static void main(String[] args) throws IllegalAccessException, InstantiationException {
Fruit fruit= createInstance(Fruit .class);
People people= createInstance(People.class);
}
}
那Class<T>和Class<?>有什么区别呢?
Class<T>在实例化的时候,T要替换成具体类
Class<?>它是个通配泛型,?可以代表任何类型,主要用于声明时的限制情况
例如可以声明一个
public Class<?> clazz;
但是你不能声明一个
public Class<T> clazz;
因为T需要指定类型
所以当,不知道定声明什么类型的Class的时候可以定义一个Class<?>,Class<?>可以用于参数类型定义,方法返回值定义等。
以上所有示例的代码我已经提交到了github,有兴趣的同学可以去看看https://github.com/qwertyanglu/FanxingDemo
个人的一些理解,如果有不对的地方,欢迎各位前辈给出宝贵指导,在此先行谢过。
作者:程序鱼
链接:https://www.jianshu.com/p/95f349258afb
來源:简书
简书著作权归作者所有,任何形式的转载都请联系作者获得授权并注明出处。