java_reflect

2018-04-04

Class类

面向对象的世界里，万物皆对象。
类是对象，类是java.lang.class类的实例对象

public class Student{
    private String name;
}
public static void main(String []args){
    Student student = new Student();
}

student 是Student 类的对象，那么Student类是谁的对象呢？是java.lang.Class 的实例对象

/*
    * Private constructor. Only the Java Virtual Machine creates Class objects.
    * This constructor is not used and prevents the default constructor being
    * generated.
    */
   private Class(ClassLoader loader) {
       // Initialize final field for classLoader.  The initialization value of non-null
       // prevents future JIT optimizations from assuming this final field is null.
       classLoader = loader;
   }

java.lang.Class这个类是私有构造器，只能被jvm创建.

如何表示Class类实例对象

1 2	Student student = new Student(); //student 是Student的对象 public class Student{} //Student 是 java.lang.Class 的对象：类类型（class type)

//第一种方式：告诉我们任何一个类都有一个隐式的静态成员
Class c1 = Student.class;
//第二种方式：已经知道该类的对象，通该类的对象获取
Class c2 = student.getClass();
//第三种方式:知道类的全称
Class c3 =null;
c3 = Class.forName("com.example.Student");

//通过以上的方式创建的类类型 是相同的。
c1== c2== c3

Class.forName(“类的全称”)

不仅表示类的类类型，还代表了动态加载类

编译时加载的类是静态加载类；运行时加载类是动态加载类

1
2

例如一个程序有100个功能，只要有一个Class不能用，程序就不能启动。这是因为编译时会把所有可能用到的类加载，可能实际中都没有使用这个类。
通过Class.forName()是动态加载类，用到哪个类，就加载哪个类。可以达到绕过编译；

类类型的作用

获取类的实例对象

1	Student student1 = (Student) c1.newInstance();//Student 要有一个无参的构造函数

获取类的信息(类的成员函数，成员变量)


/**
 * @author liuwang
 * @date 2018/7/9
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface Login {
    String value() default "";
}

   
/**
 * @author liuwang
 * @date 2018/7/8
 */
@Login("admin")
public class Student {
    //...
}

/**
 * @author liuwang
 * @date 2018/7/8
 */
public class ClassUtil {

    public static void getClassMessage(Object obj){
        //获取类类型
        Class clazz = obj.getClass();

        System.out.println("--------------------开始打印类的基本信息 ----------------");
        //获取类的名称
        System.out.println("类的名称"+clazz.getName()+"类的简名"+clazz.getSimpleName());
        System.out.println("父类的名称"+clazz.getSuperclass().getName()+"父类的简名"+clazz.getSuperclass().getSimpleName());

        System.out.println("--------------------开始打印类的所有成员变量 ----------------");
        Field[] declaredFields = clazz.getDeclaredFields();
        for (Field field:declaredFields){
            //获取成员变量的类类型
            Class fieldType = field.getType();
            //获取成员变量的变量名
            String fieldName = field.getName();
            System.out.println(fieldType.getSimpleName()+" "+fieldName+";");
        }
        System.out.println("--------------------开始打印类的构造器 ----------------");
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for (Constructor constructor :declaredConstructors){
            //构造函数的名称
            String name = constructor.getName();
            //获取构造函数的参数列表
            String paramTypeName = StringUtils.join(constructor.getParameterTypes(), ",");
            System.out.println(name+"( "+ paramTypeName+")");
        }

        System.out.println("--------------------开始打印类的所有方法 ----------------");
        //获取类的所有方法（public)，包括父类继承的
        Method[] methods = clazz.getMethods();
        //获取类所有方法（不受访问控制符限制）
        Method[] methods1 =clazz.getDeclaredMethods();
        for (Method method :methods){
            //获取方法的返回值的类类型
            Class returnType = method.getReturnType();
            System.out.print(returnType.getSimpleName()+ " ");
            //获取方法的名称
            System.out.print(method.getName()+ "(");
            //获取参数的类类型
            Class[] paramTypes = method.getParameterTypes();
            System.out.println(StringUtils.join(paramTypes, ",")+")");
        }
    }
    /**
     * 获取类上注解@Login的信息
     * @param obj
     */
    public static void getClassAnnotationMessage(Object obj){
        //获取类类型
        Class clazz = obj.getClass();
        Annotation[] annotations = clazz.getAnnotations();
        for(Annotation annotation:annotations){
            Class<? extends Annotation> aClass = annotation.annotationType();
            System.out.println("类上的注解有："+ aClass);
            if(annotation instanceof Login){
                System.out.println("注解的值："+((Login) annotation).value());
            }
        }
    }
    public static void main(String[] args) {
        String str = new String();
        Student student = new Student();
        getClassAnnotationMessage(student);
        getClassMessage(str);
    }
}

输出结果为：

类上的注解有：interface com.example.Login
注解的值：admin
--------------------开始打印类的基本信息 ----------------
类的名称java.lang.String类的简名String
父类的名称java.lang.Object父类的简名Object
--------------------开始打印类的所有成员变量 ----------------
char[] value;
int hash;
long serialVersionUID;
ObjectStreamField[] serialPersistentFields;
Comparator CASE_INSENSITIVE_ORDER;
--------------------开始打印类的构造器 ----------------
java.lang.String( class [B,int,int)
java.lang.String( class [B,class java.nio.charset.Charset)
java.lang.String( class [B,class java.lang.String)
java.lang.String( class [B,int,int,class java.nio.charset.Charset)
java.lang.String( class [B,int,int,class java.lang.String)
java.lang.String( class [C,boolean)
...
--------------------开始打印类的所有方法 ----------------
boolean equals(class java.lang.Object)
String toString()
int hashCode()
int compareTo(class java.lang.String)
int compareTo(class java.lang.Object)
int indexOf(class java.lang.String,int)
int indexOf(class java.lang.String)
int indexOf(int,int)
int indexOf(int)
String valueOf(int)
...

方法的反射

方法名+参数列表：唯一确定一个方法
方法反射：
1
method.invoke(对象，参数列表)

例子

/**
 * @author liuwang
 * @date 2018/7/9
 */
public class MethodInvoke {

    static class A{
        public void print(int a,int b){
            System.out.println(a+b);
        }

        public void print(String a,String b){
            System.out.println(a.toUpperCase()+","+b.toUpperCase());
         }
    }

    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        A a = new A();
        Class clazz = a.getClass();
        //获取方法
        Method print = clazz.getMethod("print", new Class[]{int.class, int.class});
        print.invoke(a,new Object[]{10,20});
    }
}

结果: