Day33.通过反射获取运行时类对象 及其主要结构、反射的应用(动态代理)

目录​​​​​​​

通过反射获取运行时类对象*

体会的反射动态性

反射获取运行时类的完整结构

调用运行时类的主要结构**

---

通过反射获取运行时类对象*

    @Test       //exception: 没有无参、非法访问(该无参是私有的、权限不够)
    public void test() throws InstantiationException, IllegalAccessException {
        //Class clazz = Person.class;
        Class clazz = Person.class;
        /*
        newInstance(); 调用此方法，创建对应的运行时类的对象。内部调用了运行时类的无参构造
        要想此方法正常的创建运行时类的对象，要求：
        1、运行时类必须提供无参构造
        2、无参构造的访问权限得够。通常为public。

        通常在javabean中要求提供一个public的空参构造器
        原因：1、便于通过反射、创建运行时类的对象
             2、便于子类继承此运行时类时，默认调用super()时候，保证父类有此构造器
         */
        Object obj = clazz.newInstance();
        System.out.println(obj);
    }

体会的反射动态性

    //框架通用的结构得益于反射的动态性
    //体会反射的动态性；运行时随机创建某个类的对象
    @Test
    public void test2(){
        int num = new Random().nextInt(3);//0,1,2
        String classPath = "";
        switch(num){
            case 0:
                classPath = "java.util.Date";
                break;
            case 1:
                classPath = "java.lang.Object";
                break;
            case 2:
                classPath = "com.Reflection.Person";
                break;
        }
        try {
            Object obj = getInstance(classPath);
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /*
    创建一个指定类的对象。
    classPath：指定类的全类名
     */
    public Object getInstance(String classPath) throws Exception {
        Class clazz = Class.forName(classPath);
        return clazz.newInstance();
    }

反射获取运行时类的完整结构

/*
* 获取运行时类的属性结构
*
* */
public class FieldTest {
    @Test
    public void test1(){
        Class clazz = Person.class;
        //获取属性结构
        //getFields():获取当前运行时类及其父类中声明为public 访问权限的属性
        Field[] fields = clazz.getFields();
        for(Field f : fields){
            System.out.println(f);
        }
        System.out.println("----------------");

        //getDeclaredFields():获取当前运行时类中声明的所有属性（不包含父类中声明的属性）
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            System.out.println(f);
        }
    }
    //权限修饰符 数据类型 变量名
    @Test
    public void test2() {
        Class clazz = Person.class;
        Field[] declaredFields = clazz.getDeclaredFields();
        for(Field f : declaredFields){
            //1.权限修饰符
            int modifiers = f.getModifiers();
            //System.out.println(modifiers); //2 0 1
            System.out.print(Modifier.toString(modifiers) + "\t"); //private (默认) public

            //2.数据类型
            Class type = f.getType();
            System.out.print(type.getName() + "\t");

            //3.变量名
            String fName = f.getName();
            System.out.print(fName);

            System.out.println();
        }
    }
}

        Class clazz = Person.class;
        //获取方法
        //getMethods: 获取当前运行时类及其所有父类中声明为public权限的方法
        Method[] methods = clazz.getMethods();
        for(Method m :methods){
            System.out.println(m);
        }
        System.out.println("--------------------");
        //getDeclaredMethods: 获取当前运行时类当中声明的所有方法。(不包含父类)
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            System.out.println(m);
        }
        //获取构造方法
        System.out.println("--------------------");
        //getConstructors: 获取当前运行时类及其所有父类中声明为public权限的构造方法。(不包含父类)
        Constructor[] constructors = clazz.getConstructors();
        for(Constructor c:constructors){
            System.out.println(c);
        }
        System.out.println("--------------------");
        //getConstructors: 获取当前运行时类当中声明的所有构造方法。(不包含父类)
        Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
        for(Constructor c : declaredConstructors){
            System.out.println(c);
        }

    /*
    @Xxx
    * 权限修饰符 返回值类型 方法名(参数类型1 形参名1，) throws XxxExeption
    * */
    @Test
    public void test2(){
        Class clazz = Person.class;
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for(Method m : declaredMethods){
            //1.获取方法声明的注解
            Annotation[] annos = m.getAnnotations();
            for(Annotation a : annos){
                System.out.println(a);
            }
            //2.权限修饰符
            System.out.print(Modifier.toString(m.getModifiers()) + "\t");

            //3.返回值类型
            System.out.print(m.getReturnType().getName() +"\t");

            //4.方法名
            System.out.print(m.getName());
            System.out.print("(");
            //5.形参列表
            Class[] parameterTypes = m.getParameterTypes();
            if(!(parameterTypes == null && parameterTypes.length == 0)){
                //很多形参，需要循环
                for(int i = 0 ; i < parameterTypes.length ; i++){
                    if(i == parameterTypes.length -1){
                        System.out.print(parameterTypes[i].getName() + " args_"+ i);
                        break;
                    }
                    System.out.print(parameterTypes[i].getName() + " args_"+ i +",");
                }
            }
            System.out.print(")");

            //6.抛出的异常
            Class[] exceptionTypes = m.getExceptionTypes();
            if(exceptionTypes.length >0){
                System.out.print("throws");
                for(int i = 0; i < exceptionTypes.length;i++){
                    if(i == exceptionTypes.length - 1){
                        System.out.print(exceptionTypes[i].getName());
                        break;
                    }
                    System.out.print(exceptionTypes[i].getName()+ ",");
                }
            }
            System.out.println();
        }
    }

public    int    compareTo(java.lang.String args_0)
public volatile    int    compareTo(java.lang.Object args_0)
public    void    info()
@com.Reflection1.MyAnnotation(value=abc)
private    java.lang.String    show(java.lang.String args_0)
public    java.lang.String    display(java.lang.String args_0,int args_1)throwsjava.lang.NullPointerException,java.lang.ClassCastException

调用运行时类的主要结构**

如何操作运行时类指定的属性 -- 掌握

    /*
    如何操作运行时类指定的属性 -- 掌握
     */
    @Test
    public void testField1() throws Exception {
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        //1.getDeclaredField(String fiedName):获取运行时类中指定变量名的属性
        Field name = clazz.getDeclaredField("name");

        //name.set(p,"Tom"); 由于封装 无法直接修改
        //2.保证当前属性是可访问的
        name.setAccessible(true);
        //3.获取，设置指定对象的此属性值
        name.set(p,"Tom");

        System.out.println(name.get(p));
    }

    @Test
    public void testField() throws Exception{
        Class clazz = Person.class;
        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();
        //获取指定的属性，要求运行时类的属性声明为public(通常不采用)
        Field id = clazz.getField("id");
        /*
        设置当前属性的值
        set()  参数1: 指明设置哪个对象的属性， 参数2: 将此属性设置为多少
        */

        id.set(p,1001);
        /*
        获取当前属性的值
        get()  参数1: 获取哪个对象的当前属性值
         */
        int pId = (int) id.get(p);
        System.out.println(pId);
    }

如何操作运行时类中的指定的方法 -- 需要掌握

    /*
    如何操作运行时类中的指定的方法 -- 需要掌握
     */
    @Test
    public void testMethod() throws Exception{
        Class clazz = Person.class;

        //创建运行时类的对象
        Person p = (Person) clazz.newInstance();

        /*
        1.获取指定的某个方法
        getDeclaredMethod() 参数1:指明获取方法的名称 参数2:指明获取方法的形参列表
         */
        Method show = clazz.getDeclaredMethod("show", String.class);
        //2.保证当前的方法是可访问的
        show.setAccessible(true);
        /*
        3.调用执行invoke(): 参数1:方法的调用者  参数2:给方法形参赋值的实参
        invoke()的返回值即为对应类中调用的方法的返回值。
         */
        Object returnValue = show.invoke(p, "CHN");//我的国籍是:CHN
        System.out.println(returnValue);//CHN

        System.out.println("---------如何调用静态方法--------");
        //private static void speak()
        //1.获取方法
        Method spack = clazz.getDeclaredMethod("speak");
        //2.设置为可访问
        spack.setAccessible(true);
        //3.调用方法
        //调用静态方法的区别，由于是静态方法，方法调用者可为noll，因为谁调都一样
        spack.invoke(null);//你好，世界
        //如果方法没有返回值，invoke方法默认返回值为noll
    }

Class类常用方法：

T	newInstance()           创建此 Class 对象所表示的类的一个新实例。
static Class	forName(String className)           返回与带有给定字符串名的类或接口相关联的 Class 对象。
static Class	forName(String name, boolean initialize, ClassLoader loader)           使用给定的类加载器，返回与带有给定字符串名的类或接口相关联的 Class 对象。
Field	getField(String name)  (获取public属性)           返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
Field[]	getFields()           返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
Field[]	getDeclaredFields()           返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。
Method	getMethod(String name, Class... parameterTypes)           返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Method[]	getMethods()           返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。
Method[]	getDeclaredMethods()           返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
Constructor	getConstructor(Class... parameterTypes)           返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
Constructor[]	getConstructors()           返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
int	getModifiers()           返回此类或接口以整数编码的 Java 语言修饰符。
ClassLoader	getClassLoader()           返回该类的类加载器。
Class[]	getInterfaces()           确定此对象所表示的类或接口实现的接口。
Class	asSubclass(Class clazz)           强制转换该 Class 对象，以表示指定的 class 对象所表示的类的一个子类。
T	cast(Object obj)           将一个对象强制转换成此 Class 对象所表示的类或接口。
boolean	desiredAssertionStatus()           如果要在调用此方法时将要初始化该类，则返回将分配给该类的断言状态。
A	getAnnotation(Class annotationClass)           如果存在该元素的指定类型的注释，则返回这些注释，否则返回 null。
Annotation[]	getAnnotations()           返回此元素上存在的所有注释。
String	getCanonicalName()           返回 Java Language Specification 中所定义的底层类的规范化名称。
Class[]	getClasses()           返回一个包含某些 Class 对象的数组，这些对象表示属于此 Class 对象所表示的类的成员的所有公共类和接口。
Class	getComponentType()           返回表示数组组件类型的 Class。
Annotation[]	getDeclaredAnnotations()           返回直接存在于此元素上的所有注释。
Class[]	getDeclaredClasses()           返回 Class 对象的一个数组，这些对象反映声明为此 Class 对象所表示的类的成员的所有类和接口。
Constructor	getDeclaredConstructor(Class... parameterTypes)           返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。
Constructor[]	getDeclaredConstructors()           返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。
Field	getDeclaredField(String name)           返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
Method	getDeclaredMethod(String name, Class... parameterTypes)           返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Class	getDeclaringClass()           如果此 Class 对象所表示的类或接口是另一个类的成员，则返回的 Class 对象表示该对象的声明类。
Class	getEnclosingClass()           返回底层类的立即封闭类。
Constructor	getEnclosingConstructor()           如果该 Class 对象表示构造方法中的一个本地或匿名类，则返回 Constructor 对象，它表示底层类的立即封闭构造方法。
Method	getEnclosingMethod()           如果此 Class 对象表示某一方法中的一个本地或匿名类，则返回 Method 对象，它表示底层类的立即封闭方法。
T[]	getEnumConstants()           如果此 Class 对象不表示枚举类型，则返回枚举类的元素或 null。
Type[]	getGenericInterfaces()           返回表示某些接口的 Type，这些接口由此对象所表示的类或接口直接实现。
Type	getGenericSuperclass()           返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type。
String	getName()           以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。
Package	getPackage()           获取此类的包。
ProtectionDomain	getProtectionDomain()           返回该类的 ProtectionDomain。
URL	getResource(String name)           查找带有给定名称的资源。
InputStream	getResourceAsStream(String name)           查找具有给定名称的资源。
Object[]	getSigners()           获取此类的标记。
String	getSimpleName()           返回源代码中给出的底层类的简称。
Class	getSuperclass()           返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的超类的 Class。
TypeVariable>[]	getTypeParameters()           按声明顺序返回 TypeVariable 对象的一个数组，这些对象表示用此 GenericDeclaration 对象所表示的常规声明来声明的类型变量。
boolean	isAnnotation()           如果此 Class 对象表示一个注释类型则返回 true。
boolean	isAnnotationPresent(Class annotationClass)           如果指定类型的注释存在于此元素上，则返回 true，否则返回 false。
boolean	isAnonymousClass()           当且仅当底层类是匿名类时返回 true。
boolean	isArray()           判定此 Class 对象是否表示一个数组类。
boolean	isAssignableFrom(Class cls)           判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。
boolean	isEnum()           当且仅当该类声明为源代码中的枚举时返回 true。
boolean	isInstance(Object obj)           判定指定的 Object 是否与此 Class 所表示的对象赋值兼容。
boolean	isInterface()           判定指定的 Class 对象是否表示一个接口类型。
boolean	isLocalClass()           当且仅当底层类是本地类时返回 true。
boolean	isMemberClass()           当且仅当底层类是成员类时返回 true。
boolean	isPrimitive()           判定指定的 Class 对象是否表示一个基本类型。
boolean	isSynthetic()           如果此类是复合类，则返回 true，否则 false。
String	toString()           将对象转换为字符串。