class

因为还还未想好怎么整理这篇文章，以什么为标题?,以什么为主要内容？，所以仅仅作为自己的笔记，供以后查询，也许以后，自己只是更丰富，他会成为一篇文章
ParameterizedType，带有泛型的就是参数化类型，

public interface ParameterizedType extends Type {
	//获取泛型的参数，获取到的是一个数组，里面返回泛型的具体类型，例如下面map1,返回的是[java.lang.String,java.lang.Long]的Type数组
    Type[] getActualTypeArguments();
	//获取它本身的类型，例如下面的对象中的map1，通过field中获取的RawType就是Map
    Type getRawType();
    //官方解释，就是内部类的外部类的类型
	//Returns a {@code Type} object representing the type that this type
     // is a member of.  For example, if this type is {@code O<T>.I<S>},
  //return a representation of {@code O<T>}.
    Type getOwnerType();
}		

例如，下面的list1,map1,map3都是参数化类型

public class ParameterizedBean { 
		List<String> list1; 
		List list2; 
		Map<String,Long> map1;
		 Map map2; 
		 Map.Entry<Long,Short> map3;
  }

WildcardType　通配符表达式

public interface WildcardType extends Type {
	 //获得泛型表达式上界（上限）例如List<? extends classA >的classA
	 Type[] getUpperBounds();
	  //获得泛型表达式下界（下限） 
	  Type[] getLowerBounds();
  }

TypeVariable 测试代码

public class ConstructorTest<T extends CharSequence> { 
public static void main(String[] args) { 
	TypeVariable<Class<ConstructorTest>>[] t = ConstructorTest.class.getTypeParameters(); 
	for(TypeVariable<Class<ConstructorTest>> m : t) {
		 /**
             * 获得类型变量在声明的时候的名称，此例中为T
             */ 
             System.out.println(m.getName());
              /**
             * 获得类型变量的上边界，若无显式的定义（extends）,默认为Object;类型变量的上边界可能不止一个，
             * 因为可以用&符号限定多个（这其中有且只能有一个为类或抽象类，且必须放在extends后的第一个，
             * 即若有多个上边界，则第一个&后必须为接口）
             * 
             */
              Type[] bounds = m.getBounds(); for(Type t1 : bounds) { System.out.println(t1); } /**
             * 获得声明这个类型变量的类型及名称
             * 类中：class reflect.ConstructorTest
             */ 
             System.out.println(m.getGenericDeclaration());
        } } }

GenericArrayType　//represents an array type whose component　type is either a parameterized type or a type variable.

class.getDeclaredClasses() 获取class里面申明的所有类和接口

//返回类型的直接的父类，如果父类是参数化类型（泛型），则需要返回具体的参数的类型，例如下面的实例代码,这样的话，我们就可以通过class,获取泛型的类型，然后做具体的操作
class.getGenericSuperclass();

public class CustomMap extend HashMap<String,Integer>{
	{
		Type genericSuperclass = getClass().getgetGenericSuperclass();
		if (genericSuperclass instanceof ParameterizedType) {
            Log.d(TAG,"instanceof = "+true);
            ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
            //这里面返回的东西实际上是Class类型，
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (int i = 0; i < actualTypeArguments.length; i++) {
                Log.d(TAG,"" + actualTypeArguments[i]);
            }
            //返回当前类型的拥有者类型，就是内部类类型的外部类
            Log.d(TAG,"getOwnerType = "+parameterizedType.getOwnerType());
            //返回申明此类型的类型或者借口，因为这里是在HashMap中申明的，则返回的类型为java.util.HashMap
            Log.d(TAG,"getRawType = "+parameterizedType.getRawType());
        }
	}
}

打印出来的内容为

06-20 09:59:30.371 32374 32374 D CustomMap: instanceof = true
06-20 09:59:30.371 32374 32374 D CustomMap: class java.lang.String
06-20 09:59:30.371 32374 32374 D CustomMap: class java.lang.Integer
06-20 09:59:30.371 32374 32374 D CustomMap: getOwnerType = null
06-20 09:59:30.371 32374 32374 D CustomMap: getRawType = class java.util.HashMap

getTypeParameters()方法，用于获取当前类型上面申明的泛型通配符的类型

//这里的TestSuperClass是任意一个自定义对象，仅仅作为演示用
public class CustomMap<T extends TestSuperClass>{
	{
		TypeVariable<? extends Class<? extends CustomMap>>[] typeParameters = getClass().getTypeParameters();
    for (TypeVariable<? extends Class<? extends CustomMap>> typeParameter : typeParameters) {
        Log.d(TAG, "typeParameter = " + typeParameter.getName());
        Type[] bounds = typeParameter.getBounds();
        for (Type bound : bounds) {
            Log.d(TAG,"bound = "+bound);
        }
        Class<? extends CustomMap> genericDeclaration = typeParameter.getGenericDeclaration();
        Log.d(TAG,"genericDeclaration = "+genericDeclaration);
    }
	}
}

上面的打印结果是

06-20 10:40:27.100 16458 16458 D CustomMap: typeParameter = T
06-20 10:40:27.100 16458 16458 D CustomMap: bound = class com.ijourney.test.TestSuperClass
06-20 10:40:27.100 16458 16458 D CustomMap: genericDeclaration = class com.ijourney.test.CustomMap

getEnclosingClass 获取当前类是在哪个类里面定义的，比如直接定义的内部类或匿名内部类