package lei;
/**
 * 获取某一个类的类类型的方法
 * @author Administrator
 *
 */
public class LeiName {
    public static void main(String[] args) {

        //方法一、通过类名调用自身隐含的class静态变量，通过class调用类类型
        @SuppressWarnings("rawtypes")
        Class c1=LeiName.class;

        //方法二、通过对象调用该类继承与Object类的getClass方法
        LeiName ln=new LeiName();
        @SuppressWarnings("rawtypes")
        Class c2=ln.getClass();

        //方法三、使用Class的forName方法，动态加载类
        @SuppressWarnings("rawtypes")
        Class c3=null;
        try {
             c3=Class.forName("lei.LeiName");
        } catch (ClassNotFoundException e) {
        }
        System.out.println(c1==c2);
        System.out.println(c2==c3);
    }

}
结果为true

文章目录
泛型速解
强类型
共用性
继承泛型父类获取具体类型的实例

泛型速解
泛型是类型的参数。
强类型
在JDK中，最常见的的用法就是容器类的元素类型的指定。以List为例，通过List<元素类型>指定容器中元素的类型。

如果不通过尖括号指定类型，容器中可以添加任何类型的元素，因为在Java中所有对象类型都继承自Object父类，但Java是强类型语言，限定容器内元素的具体类型是推荐的方式。
共用性
这样可能会问？ 直接在定义List等类时，直接限定元素类型不就可以了吗？ 如果这样的化，共用性基本没有， 不同元素类型需要定义不同的List类。
继承泛型父类获取具体类型的实例
AbstractService - 泛型抽象父类

MyService - 继承AbstractService父类，并指定泛型的类型

在AbstractService中获取实际类型的代码如下：
	@SuppressWarnings("unchecked")
	public Class<Object> getActualClass() {
		// Class<T> tClass = (Class<T>) ((ParameterizedType)
		// getClass().getGenericSuperclass()).getActualTypeArguments()[0];
		Class<Object> actualClass = null;
		Type genType = getClass().getGenericSuperclass();
		if (!(genType instanceof ParameterizedType)) {
			actualClass = Object.class;
		} else {
			ParameterizedType pt = (ParameterizedType) genType;
			actualClass = (Class<Object>) pt.getActualTypeArguments()[0];
		}
		return actualClass;
	}

这里有两个主要方法：

getGenericSuperclass()  ， 获取该类的直接父类
getActualTypeArguments(), 获取泛型类的类型， 也就是T， 该方法返回的是一个数组， 因为对于HashMap<K,V>等会有多个泛型参数。

完整代码：

https://github.com/osxm/jcodef/tree/master/jcodef-func/src/main/java/cn/osxm/jcodef/func/generics

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @author 长得太帅，要好好反省！
 * @description 两个泛型的类
 */
class Person<T1,T2> {
}

/**
 * 继承的时候，泛型被显式地指定了Integer, Boolean，所以能够被通过反射获取
 */
class Student extends Person<Integer, Boolean> {

    public static void main(String[] args) {

        Student student = new Student();
        Class clazz = student.getClass();
        //getSuperclass()获得该类的父类
        System.out.println(clazz.getSuperclass());

        /**
         * getGenericSuperclass()获得带有泛型的父类
         * Type是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
         */
        Type type = clazz.getGenericSuperclass();
        System.out.println(type);

        //ParameterizedType参数化类型，即泛型
        ParameterizedType p = (ParameterizedType)type;
        //getActualTypeArguments获取参数化类型的数组，泛型可能有多个
        Class c1 = (Class)p.getActualTypeArguments()[0];
        System.out.println(c1);
        Class c2 = (Class)p.getActualTypeArguments()[1];
        System.out.println(c2);
    }
}

JAVA获取方法信息

在类里声明的返回值类型、基本数据类型等有.class方法，获取类的类类型，如：int.class、String.class、double.class、void.class等
获取类的全部信息：

//jni本地方法,java声明,C实现
//要获取类的信息，首先要获取类的类类型
Class c = obj.getClass();   

//获取类名称
c.getName()

//Method类，方法对象
//一个成员方法就是一个Method对象
//getMethods()方法获取的是所有的public的函数，包括由父类继承而来
//getDeclaredMethods()获取的是所有该类自己声明的方法，不问访问权限
Method[] ms = c.getMethods();

//得到方法返回值类型
Class returnType = ms[i].getReturnType();

//得到方法名
ms[i].getName();

//获取参数类型数组
Class[] paramTypes = ms[i].getParameterTypes();