java笔记--反射机制之基础总结与详解

一.反射之实例化Class类的5种方式：

java的数据类型可以分为两类，即引用类型和原始类型（即基本数据类型）。
对于每种类型的对象，java虚拟机会实例化不可变的java.lang.Class对象。
它提供了在运行时检查对象属性的方法，这些属性包括它的成员和类型信息。

更重要的是Class对象是所有反射API的入口。

Class类是泛型类，可以使用@SuppressWarnings("unchecked")忽略泛型或者使用Class<V>类型。

获得Class对象的5种方式：

1."Object.getClass()"   : 如果一个类的对象可用，则最简单的获得Class的方法是使用Object.getClass()。
                                    当然，此方式只对引用类型有效。

2. ".class"------------- : 如果类型可用但没有对象，则可以在类型后加上".class"来获得Class对象。这也是使原始类型
                                    获得Class对象最简单的方式：
3."Class.forName()"---:  如果知道类的全名，则可以使用静态方法Class.forName()来获得Class对象，它不能用在原始类型上，

但是可以用在原始类型数组上。(注：此方式会抛出ClassNotFoundException异常)
4. "包装类的TYPE域"-----:  每一个原始类型和void都有包装类。利用其TYPE域就可以获得Class对象。

5."以Class为返回值的方法": 如获取内部类的getDeclaredClasses()方法，此时返回一个对象数组

--支持知识共享，转载请标注地址"http://www.cnblogs.com/XHJT/p/3915221.html  "——和佑博客园，谢谢~~--

代码实例：

package com.xhj.reflection_excetion;

/**
 * 反射之实例化Class类的5种方式
 *
 * @author XIEHEJUN
 *
 */
public class InstantiateClassObject {

    @SuppressWarnings("rawtypes")
    public static void main(String[] args) throws ClassNotFoundException {
        System.out.print("第一种方式--用Object.getClass()方法获取到的String类的对象为： ");
        Class class1 = new String().getClass();
        System.out.println(class1.getName());    

        System.out.print("第二种方式--用.class()方法获取到的String类的对象为： ");
        class1 = String.class;
        System.out.println(class1.getName());

        System.out.print("第三种方式--用.forName()方法获取到的String类的对象为： ");
        class1 = Class.forName("java.lang.String");
        System.out.println(class1.getName());

        System.out.print("第四种方式--用包装类的TYPE域获取到的Integer类的对象为： ");
        class1 = Integer.TYPE;
        System.out.println(class1.getName());

        System.out.println("第五种方式--用getDeclaredClasses()获取String类的内部类对象：");
        Class<?>[] clazz = new String().getClass().getDeclaredClasses();
        for (Class<?> class2 : clazz) {
            System.out.println("\t"+class2);
        }

    }

}

结果为：

注：除了java.lang.reflect.ReflectPermission和java.lang.reflect包外，所有类都没有公共的

构造方法。为了获得这些类的对象，必须使用Class类中适当的方法，对于不同的数据类型，Class

对象的获得方式是不同。

二.反射之查看类的定义：

通常类的声明包括常见修饰符(public,protected,private,abstract,static,final,strictfp等)、

    类的名称、类的泛型参数、类的继承类(实现的接口)、类的注解等信息。

Class类的实例表示正在运行的Java应用程序中的类和接口：

枚举是一种类，注释是一种接口。

每一个数组属于被映射为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象；

基本数据类型和关键字void也表示为Class对象。

Class没有公共的构造方法。

Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。

   Class类常用方法：

    forName(String className)-: 根据给定的名称获得Class对象

getAnnotations()------------: 返回此Class对象上存在的注释

getCanonicalName() --------: 返回Java Language Specification 中所定义的底层类的规范化名称

getGenericInterfaces()------: 返回泛型形式的对象类所实现的接口

getGenericSuperclass() -----: 返回泛型形式的对象类所直接继承的超类

getModifuers() --------------: 返回此类或接口以整数编码的Java语言修饰符

getTypeParameters() -------: 按声明顺序返回TypeVariable对象的一个数组

注：Java语言预定义的注解只有@Deprecated可以在运行时获得。   
   
实例代码：

package com.xhj.reflection_excetion;

import java.lang.annotation.Annotation;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;

/**
 * 查看类的定义
 *
 * @author XIEHEJUN
 *
 */
public class CheckClassStatement {

    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> classtest = Class.forName("java.util.ArrayList");
        System.out.println("1.根据给定的名称获得Class对象：" + classtest.getName());
        Annotation[] annotations = classtest.getAnnotations();
        System.out.print("2.获取此对象上的注解为：");
        if (annotations.length > 0) {
            for (Annotation annotation : annotations) {
                System.out.println(annotation + "\t");
            }
        } else {
            System.out.println("空");
        }

        System.out.println("3.获得Java语言规范化名称：" + classtest.getCanonicalName());

        System.out.println("4.获取类上的修饰符：共有" + classtest.getModifiers()
                + "个，为： " + Modifier.toString(classtest.getModifiers()));

        TypeVariable<?>[] typeV = classtest.getTypeParameters();
        System.out.print("5.在对象上获取到的泛型是:");
        if (typeV.length > 0) {
            for (TypeVariable<?> typeVariable : typeV) {
                System.out.println(typeVariable);
            }
        } else {
            System.out.println("空");
        }

        System.out.println("6.在对象上获取到的接口为：");
        // 使用getInterfaces()不包含泛型;使用getGenericInterfaces包含泛型
        Type[] intefaces = classtest.getGenericInterfaces();
        if (intefaces.length > 0) {
            for (Type type : intefaces) {
                System.out.println("\t" + type);
            }
        } else {
            System.out.println("空");
        }
        Class class2 = classtest.getSuperclass();
        System.out.print("7.在对象上获取直接继承类：");
        if (class2 != null) {
            System.out.println(class2);
        } else {
            System.out.println("空");
        }

    }
}

结果为:

注：getSuperclass()方法也不能获得有泛型信息的父类

三.反射之获得Class对象表示实体的名称

对于不同类型的对象，其Class对象的名称是不同的，反过来说就是从这个名称就可以知道该对象的类型。

注：

1.如果此类对象表示的是非数组类型的引用类型，则返回该类的二进制名称。

2.如果此类对象表示一个基本类型或者void，则返回其对应的Java语言的关键字的字符串。

3.如果此类对象表示一个数组类，名字的内部形式为"[元素编码"，其深度为几维，就有几个"["。

其元素类型编码为：

——————————————————————————————————————————————————

元素类型                       编 码          
           boolean                         Z

byte                              B

char                              C

short                             S

int                                 I

float                              F

double                           D

long                              J

class or interfaces       Lclassname(即当元素是引用类型或者接口的时候，编码为"L+类名")

____________________________________________________

实例代码：

package com.xhj.reflection_excetion;

/**
 * 获取对象实体的名称
 *
 * @author XIEHEJUN
 *
 */
public class GetClassEntityName {
    /**
     * 数组元素类型编码为：
     * 元素类型                       编码
     * boolean                     Z
     * byte                       B
     * char                       C
     * short                      S
     * int                        I
     * float                      F
     * double                     D
     * long                       J
     * class or interfaces    Lclassname(即当元素是引用类型或者接口的时候，编码为"L+类名")
     */
    public static void main(String[] args) {
        System.out.println("获取非数组类型的引用类型，返回该类的二进制名称: "
                + new String().getClass().getName());
        System.out.println("获取基本类型，返回其对应的Java语言的关键字的字符串: "
                + int.class.getName());
        System.out.println("获取void类型，返回其对应的Java语言的关键字的字符串: "
                + void.class.getName());
        System.out.println("获取一维数组类型的基本类型，返回'[+元素编码': "
                + new int[2].getClass().getName());
        System.out.println("获取一维数组类型的引用类型，返回'[+元素编码': "
                + new String[2].getClass().getName());
        System.out.println("获取二维数组类型的基本类型，返回'[+元素编码': "
                + new int[2][3].getClass().getName());
        System.out.println("获取二维数组类型的引用类型，返回'[+元素编码': "
                + new String[2][3].getClass().getName());
        System.out.println("用getCanonicalName()获取二维数组类型的基本类型，返回数组名称"
                + new int[2][3].getClass().getCanonicalName());
        System.out.println("用getCanonicalName()获取二维数组类型的引用类型，返回数组名称"
                + new String[2][3].getClass().getCanonicalName());
    }

}

结果为：

注：
对于数组来说，用getCanonicalName()方法可以获取的到数组的名称，且比较容易接受和辨认

四.反射之查看类的成员

我们要查看类的定义，首先想到的当然是API文档，但若是找不到API文档又该如何呢？此时就要用到Java的反射机制了。

另外我们在无法查看源代码的情况下，也可以通过反射机制查看类的成员，包括"域，构造方法，普通方法和内部类"等。

主要用到的方法：

    getConstructors() -------: 返回由该类对象的所有构造方法组成的数组

getDeclaredFields() -----:  返回由该类对象的所有非继承域组成的数组

getDeclaredMethods() -- :  返回由该类对象的所有非继承方法组成的数组

getFields() -------------- :  返回由该类对象的所有公共域组成的数组

getMethod() -------------:  返回由该类对象的所有公共方法组成的数组

代码实例：

package com.xhj.reflection_excetion;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 查看类的成员
 *
 * @author XIEHEJUN
 *
 */
public class CheckClassMembers {

    public static void main(String[] args) {
        Class<?> strclass = new String().getClass();

        // 查看构造方法
        System.out.println(strclass.getName() + "的构造方法有：");
        Constructor<?>[] constructors = strclass.getConstructors();
        if (constructors.length > 0) {
            for (Constructor<?> constructor : constructors) {
                System.out.println("\t" + constructor);
            }
        } else {
            System.out.println("空");
        }
        // 查看非继承域
        System.out.println(strclass.getName() + "的非继承域有：");
        Field[] declaredFields = strclass.getDeclaredFields();
        if (declaredFields.length > 0) {
            for (Field field : declaredFields) {
                System.out.println("\t" + field);
            }
        } else {
            System.out.println("空");
        }

        // 查看非继承方法
        System.out.println(strclass.getName() + "的非继承方法有：");
        Method[] declaredMethods = strclass.getDeclaredMethods();
        if (declaredMethods.length > 0) {
            for (Method method : declaredMethods) {
                System.out.println("\t" + method);
            }
        } else {
            System.out.println("空");
        }

        // 查看所有公共域
        System.out.println(strclass.getName() + "的所有域有：");
        Field[] fields = strclass.getFields();
        if (fields.length > 0) {
            for (Field field : fields) {
                System.out.println("\t" + field);
            }
        } else {
            System.out.println("空");
        }

        // 查看所有公共的方法
        System.out.println(strclass.getName() + "的所有继承方法有：");
        Method[] methods = strclass.getMethods();
        if (methods.length > 0) {
            for (Method method : methods) {
                System.out.println("\t" + method);
            }
        } else {
            System.out.println("空");
        }
    }

}

结果为：

（打印出来的数据太多，这里之展示部分结果~）

注：对于私有域或方法，如果有安全管理器，可能会报异常。

五：反射之查看内部类消息

Class类的getDeclaredClasses()方法返回Class对象的一个数组，这些对象反映声明为该Class对象
所表示的类的成员的所有类和接口，包括该类所声明的公共、保护、默认（包）访问及私有类和接口，

但不包括继承的类和接口。若该类不将任何类或接口声明为成员，或者该对象表示基本类型、数组类或

void，则该方法返回一个长度为0的数组。

public Class<?> [] getDeclaredClasses() throws SecurityException

注：利用Class类的getDeclaredClasses()方法可以获得一个数组，其中的每一个成员代表一个内部类的类对象。

然后我们可以像获取普通类的信息一样，获取到内部类的信息。

代码实例：

package com.xhj.reflection_excetion;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 查看内部类的消息
 *
 * @author XIEHEJUN
 *
 */
public class CheckInnerClass {

    public static void main(String[] args) {
        Class<?> clazz = new String().getClass();
        Class[] class1 = clazz.getDeclaredClasses();
        for (int i = 0; i < class1.length; i++) {
            Class<?> innerclass = class1[i];
            System.out
                    .println("================================================================");
            System.out.println("内部类" + i + "为： " + innerclass.getName());

            System.out.println("内部类" + i + "的父类为："
                    + innerclass.getSuperclass().getName());

            System.out.print("内部类" + i + "的所有公共域为：");
            Field[] field = innerclass.getFields();
            if (field.length > 0) {
                System.out.println();
                for (Field field2 : field) {
                    System.out.println("\t" + field2);
                }
            } else {
                System.out.println("空");
            }

            System.out.print("内部类" + i + "的非继承域为：");
            Field[] declaredfield = innerclass.getDeclaredFields();
            if (declaredfield.length > 0) {
                System.out.println();
                for (Field field2 : declaredfield) {
                    System.out.println("\t" + field2);
                }
            } else {
                System.out.println("空");
            }

            System.out.print("内部类" + i + "的所有公共方法为：");
            Method[] methods = innerclass.getMethods();
            if (methods.length > 0) {
                System.out.println();
                for (Method method : methods) {
                    System.out.println("\t" + method);
                }
            } else {
                System.out.println("空");
            }

            System.out.print("内部类" + i + "的非继承方法为：");
            Method[] declaredmethods = innerclass.getDeclaredMethods();
            if (declaredmethods.length > 0) {
                System.out.println();
                for (Method method : declaredmethods) {
                    System.out.println("\t" + method);
                }
            } else {
                System.out.println("空");
            }

        }

    }

}

结果为：

（打印出来的数据太多，这里之展示部分结果~）

六.反射之按继承层次对类排序

Java提供了instanceof运算符来比较两个类（或接口）之间是否存在继承关系。

但是对于多个类来说，这种方法是很麻烦的。这时候，我们要做的应该是利用

java的反射机制来对存在继承关系的类进行排序。

主要方法：

TreeSet<E> 是基于TreeMap的NavigableSet实现的。它使用元素的自然顺序对

元素进行排序，或者根据创建set时提供的Comparator进行排序，具体取决于

使用的构造方法。本节采用Class类中的isAssignableFrom()方法来判断当前

Class 对象所表示的类与给定的Class对象所表示的类之间的关系，若相同或

是父类则返回true，否则返回false。

public boolean isAssignableFrom(Class<?> clazz)

   
注：Java中与排序相关的接口有Comparable和Comparator。这两个接口通过对象之

间比较的结果--一个有符号的整数来比较对象的大小。实现任何一个接口都可

以让对象具有排序的能力。固可以用TreeSet也可以用Arrays.sort()来进行排序。

代码实例：

package com.xhj.reflection_excetion;

import java.awt.Container;
import java.util.Comparator;
import java.util.TreeSet;

import javax.swing.JComponent;
import javax.swing.JPanel;

/**
 * 比较并将类按继承关系排序
 *
 * @author XIEHEJUN
 *
 */
public class CompareClasses implements Comparator<Class<?>> {

    @Override
    public int compare(Class<?> o1, Class<?> o2) {
        if (o1.equals(o2)) {
            return 0;
        } else if (o1.isAssignableFrom(o2)) {
            return -1;
        } else if (o2.isAssignableFrom(o1)) {
            return 1;
        } else {
            throw new IllegalArgumentException(o1+"和"+o2+"两个类之间没有联系");
        }
    }

    public static void main(String[] args) {
        TreeSet<Class<?>> treeSet = new TreeSet<Class<?>>(
                new CompareClasses());
        System.out.println("添加类——JComponent.class");
        treeSet.add(JComponent.class);
        System.out
        .println("添加类——Container.class");
        treeSet.add(Container.class);
        System.out.println("添加类——JPanel.class");
        treeSet.add(JPanel.class);
        System.out.println("=================排序后为=====================");
        for (Class<?> class1 : treeSet) {
            System.out.println(class1);
        }
    }

}

结果为：