T和Class<T>以及Class<?>的理解

T  bean ;

Class<T> bean;

Class<?> bean;

在利用反射获取属性时，遇到这样的写法，对此专门查些资料研究了一下。

单独的T 代表一个类型 而 Class<T>和Class<?>代表这个类型所对应的类

Class<T>在实例化的时候，T要替换成具体类
Class<?>它是个通配泛型，?可以代表任何类型   

<? extends T>受限统配，表示T的一个未知子类。
<? super T>下限统配，表示T的一个未知父类。

public T find(Class<T> clazz, int id);
根据类来反射生成一个实例，而单独用T没法做到。

Object类中包含一个方法名叫getClass，利用这个方法就可以获得一个实例的类型类。类型类指的是代表一个类型的类，因为一切皆是对象，类型也不例外，在Java使用类型类来表示一个类型。所有的类型类都是Class类的实例。getClass() 会看到返回Class<?>。

JDK中，普通的Class.newInstance()方法的定义返回Object，要将该返回类型强制转换为另一种类型;

但是使用泛型的Class<T>，Class.newInstance()方法具有一个特定的返回类型;

 DefaultListableBeanFactory.java   doResolveDependency 

1. protected Object doResolveDependency(DependencyDescriptor descriptor, Class<?> type, String beanName,  
2.             Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException {  
3.   
4.         Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);  
5.         if (value != null) {  
6.             if (value instanceof String) {  
7.                 String strVal = resolveEmbeddedValue((String) value);  
8.                 BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null);  
9.                 value = evaluateBeanDefinitionString(strVal, bd);  
10.             }  
11.             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  
12.             return (descriptor.getField() != null ?  
13.                     converter.convertIfNecessary(value, type, descriptor.getField()) :  
14.                     converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));  
15.         }  
16.   
17.         if (type.isArray()) {  
18.             Class<?> componentType = type.getComponentType();  
19.             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);  
20.             if (matchingBeans.isEmpty()) {  
21.                 if (descriptor.isRequired()) {  
22.                     raiseNoSuchBeanDefinitionException(componentType, "array of " + componentType.getName(), descriptor);  
23.                 }  
24.                 return null;  
25.             }  
26.             if (autowiredBeanNames != null) {  
27.                 autowiredBeanNames.addAll(matchingBeans.keySet());  
28.             }  
29.             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  
30.             return converter.convertIfNecessary(matchingBeans.values(), type);  
31.         }  
32.         else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {  
33.             Class<?> elementType = descriptor.getCollectionType();  
34.             if (elementType == null) {  
35.                 if (descriptor.isRequired()) {  
36.                     throw new FatalBeanException("No element type declared for collection [" + type.getName() + "]");  
37.                 }  
38.                 return null;  
39.             }  
40.             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, descriptor);  
41.             if (matchingBeans.isEmpty()) {  
42.                 if (descriptor.isRequired()) {  
43.                     raiseNoSuchBeanDefinitionException(elementType, "collection of " + elementType.getName(), descriptor);  
44.                 }  
45.                 return null;  
46.             }  
47.             if (autowiredBeanNames != null) {  
48.                 autowiredBeanNames.addAll(matchingBeans.keySet());  
49.             }  
50.             TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());  
51.             return converter.convertIfNecessary(matchingBeans.values(), type);  
52.         }  
53.         else if (Map.class.isAssignableFrom(type) && type.isInterface()) {  
54.             Class<?> keyType = descriptor.getMapKeyType();  
55.             if (keyType == null || !String.class.isAssignableFrom(keyType)) {  
56.                 if (descriptor.isRequired()) {  
57.                     throw new FatalBeanException("Key type [" + keyType + "] of map [" + type.getName() +  
58.                             "] must be assignable to [java.lang.String]");  
59.                 }  
60.                 return null;  
61.             }  
62.             Class<?> valueType = descriptor.getMapValueType();  
63.             if (valueType == null) {  
64.                 if (descriptor.isRequired()) {  
65.                     throw new FatalBeanException("No value type declared for map [" + type.getName() + "]");  
66.                 }  
67.                 return null;  
68.             }  
69.             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, descriptor);  
70.             if (matchingBeans.isEmpty()) {  
71.                 if (descriptor.isRequired()) {  
72.                     raiseNoSuchBeanDefinitionException(valueType, "map with value type " + valueType.getName(), descriptor);  
73.                 }  
74.                 return null;  
75.             }  
76.             if (autowiredBeanNames != null) {  
77.                 autowiredBeanNames.addAll(matchingBeans.keySet());  
78.             }  
79.             return matchingBeans;  
80.         }  
81.         else {  
82.             Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor);  
83.             if (matchingBeans.isEmpty()) {  
84.                 if (descriptor.isRequired()) {  
85.                     raiseNoSuchBeanDefinitionException(type, "", descriptor);  
86.                 }  
87.                 return null;  
88.             }  
89.             if (matchingBeans.size() > 1) {  
90.                 String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);  
91.                 if (primaryBeanName == null) {  
92.                     throw new NoUniqueBeanDefinitionException(type, matchingBeans.keySet());  
93.                 }  
94.                 if (autowiredBeanNames != null) {  
95.                     autowiredBeanNames.add(primaryBeanName);  
96.                 }  
97.                 return matchingBeans.get(primaryBeanName);  
98.             }  
99.             // We have exactly one match.  
100.             Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next();  
101.             if (autowiredBeanNames != null) {  
102.                 autowiredBeanNames.add(entry.getKey());  
103.             }  
104.             return entry.getValue();  
105.         }  
106.     }