Class T ？Object

？ 表示不确定的java类型。

T 表示java类型。

K V 分别代表java键值中的Key Value。

E 代表Element。

Object跟这些东西代表的java类型有啥区别呢？ 
Object是所有类的根类，是具体的一个类，使用的时候可能是需要类型强制转换的，但是用T ？等这些的话，在实际用之前类型就已经确定了，不需要强制转换。

第一种是固定的一种泛型，第二种是只要是Object类的子类都可以，换言之，任何类都可以，因为Object是所有类的根基类
固定的泛型指类型是固定的，比如：Interge,String. 就是<T extends Collection>

<？ extends Collection> 这里？代表一个未知的类型，
但是，这个未知的类型实际上是Collection的一个子类，Collection是这个通配符的上限.
举个例子
class Test <T extends Collection> { }

<T extends Collection>其中,限定了构造此类实例的时候T是一个确定类型(具体类型)，这个类型实现了Collection接口，
但是实现 Collection接口的类很多很多，如果针对每一种都要写出具体的子类类型，那也太麻烦了，干脆还不如用
Object通用一下。
<? extends Collection>其中,?是一个未知类型,是一个通配符泛型,这个类型是实现Collection接口即可。

1 2 3

The method take(Animal) in the type Test is not applicable  for  the arguments (Demo<Dog>) The method take(Animal) in the type Test is not applicable  for  the arguments (Demo<Cat>) The method take(Animal) in the type Test is not applicable  for  the arguments (Demo<Animal>)

1 2 3 4 5 6 7 8

public  class  Demo <T  extends  Animal>{     private  T ob;     public  T getOb() {         return  ob;      }     public  void setOb(T ob) {        this.ob = ob;      }     public  Demo(T ob) {        super();        this.ob = ob;      }         public  void  print (){          System.out.println( "T的类型是：" +ob.getClass().getName());      } }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

public  <T> Class<T> resolveAlias(String string) {        try  {             if  (string ==  null ) {               return  null ;       }            // issue #748       String key = string.toLowerCase(Locale.ENGLISH);       Class<T> value;            if  (TYPE_ALIASES.containsKey(key)) {              value = (Class<T>) TYPE_ALIASES.get(key);       }  else  {              value = (Class<T>) Resources.classForName(string);       }            return  value;     }  catch  (ClassNotFoundException e) {          throw  new  TypeException( "Could not resolve type alias '"  + string +  "'.  Cause: "  + e, e);     }   }

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

public  class  Base {    private  static  Map<String, Class<?>> map =  new  HashMap<>();    static  {        map.put( "string" , String. class );        map.put( "integer" , Integer. class );      }      @SuppressWarnings ( "unchecked" )         public  <T> Class<T> get(String str) {             return  (Class<T>) map.get(str);      }      @Test         public  void  t()  throws  IllegalAccessException, InstantiationException {          Base base =  new  Base();          Class<Integer> string = base.get( "string" );          System.out.println(string);      } }

Class类的实例表示Java应用运行时的类(class ans enum)或接口(interface and annotation)（每个java类运行时都在JVM里表现为一个Class对象，可通过类名.class,类型.getClass(),Class.forName("类名")等方法获取Class对象）。数组同样也被映射为为Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为 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()方法具有一个特定的返回类型;

参照： http://josh-persistence.iteye.com/blog/2235725

           https://blog.csdn.net/J_Cxn/article/details/78581943?locationNum=8&fps=1