Java篇-反射

一 : Class解析

java.lang.Class:是反射的源头。
首先我们创建了一个类，通过编译（javac.exe）,生成对应的.class文件。之后我们使用java.exe加载（JVM的类加载器完成的）,此.class文件加载到内存以后，就是一个运行时类，存在在缓存区。那么这个运行时类本身就是一个Class的实例.

获取运行时类实例

Person p = new Person();
        Class clazz = p.getClass();//通过运行时类的对象，调用其getClass()，返回其运行时类。

1.每一个运行时类只加载一次！
2.有了Class的实例以后，我们才可以进行如下的操作：
1）创建对应的运行时类的对象
2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解、...）
3）调用对应的运行时类的指定的结构(属性、方法、构造器)
4）反射的应用：动态代理

二 : 获取Class的实例操作

• 调用运行时类本身的.class属性

Class clazz1 = Person.class;
        System.out.println(clazz1.getName());
        
Class clazz2 = String.class;
        System.out.println(clazz2.getName());

• 通过运行时类的对象获取

Person p = new Person();
        Class clazz3 = p.getClass();
        System.out.println(clazz3.getName());

• 通过Class的静态方法获取.通过此方式，体会一下，反射的动态性

String className = "com.atguigu.java.Person";
        Class clazz4 = Class.forName(className);
        System.out.println(clazz4.getName());

• 通过类的加载器

ClassLoader classLoader = this.getClass().getClassLoader();
        Class clazz5 = classLoader.loadClass(className);
        System.out.println(clazz5.getName());

证明每一个运行时类只加载一次

内存地址空间相同,证明为统一个运行时类

System.out.println(clazz1 == clazz3);//true
        System.out.println(clazz1 == clazz4);//true
        System.out.println(clazz1 == clazz5);//true

三 : 类的加载器

类加载的过程

当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过如下三个步骤来对该类进行初始化.

类加载过程

类加载器

类加载器

系统类加载器

ClassLoader loader1 = ClassLoader.getSystemClassLoader();
        System.out.println(loader1);

扩展类加载器

ClassLoader loader2 = loader1.getParent();
        System.out.println(loader2);

引导类加载器

打印结果(null) 自动加载,无法直接获取

ClassLoader loader3 = loader2.getParent();
        System.out.println(loader3);

系统类加载器加载Person 类

Class clazz1 = Person.class;
        ClassLoader loader4 = clazz1.getClassLoader();
        System.out.println(loader4);

引导类加载器自动加载

打印结果null

String className = "java.lang.String";
        Class clazz2 = Class.forName(className);
        ClassLoader loader5 = clazz2.getClassLoader();
        System.out.println(loader5);

四 : 通过反射获取Class对象和完整结构

• 获取对象

创建对应的运行时类的对象。使用newInstance()，实际上就是调用了运行时类的空参的构造器。
要想能够创建成功：
①要求对应的运行时类要有空参的构造器。
②构造器的权限修饰符的权限要足够。

person空参构造器不能用private修饰

public void test1() throws Exception{
        String className = "com.atguigu.java.Person";
        Class clazz = Class.forName(className);
        Object obj = clazz.newInstance();
        Person p = (Person)obj;
        System.out.println(p);
    }

• 获取设置运行时类的属性

① getFields()

获取到运行时类中及其父类中声明为public的属性

public void test1(){
        Class clazz = Person.class;
        Field[] fields = clazz.getFields();
        for(int i = 0;i < fields.length;i++){
            System.out.println(fields[i]);
        }
        System.out.println();
    }

② getDeclaredFields()

获取运行时类本身声明的所有的属性

Field[] fields1 = clazz.getDeclaredFields();
        for(Field f : fields1){
            System.out.println(f.getName());
        }

③获取 权限修饰符 变量类型 变量名

Class clazz = Person.class;
        Field[] fields1 = clazz.getDeclaredFields();
        for(Field f : fields1){
            //1.获取每个属性的权限修饰符
            int i = f.getModifiers();
            String str1 = Modifier.toString(i);
            System.out.print(str1 + " ");
            //2.获取属性的类型
            Class type = f.getType();
            System.out.print(type.getName() + " ");
            //3.获取属性名
            System.out.print(f.getName());
            
            System.out.println();
        }

④获取运行时类中声明为public的指定属性名为fieldName的属性

getField(String fieldName)
获取运行时类中声明为public的指定属性名为fieldName的属性

Class clazz = Person.class;
Field name = clazz.getField("name");

⑤将运行时类的指定的属性赋值

Person p = (Person)clazz.newInstance();
name.set(p,"TZ");
System.out.println("%"+name.get(p));

⑥获取运行时类中指定的名为fieldName的属性

不惧权限修饰符
getDeclaredField(String fieldName)

Field age = clazz.getDeclaredField("age");
        //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。

          //声明为protected 不在一个包的情况下也要加`age.setAccessible(true)` 否则不用加
        age.setAccessible(true);
        age.set(p,10);
        System.out.println(p);

• 获取运行时类的方法

①getMethods():

获取运行时类及其父类中所有的声明为public的方法

Method[] m1 = clazz.getMethods();
        for(Method m : m1){
            System.out.println(m);
        }
        System.out.println();

②getDeclaredMethods()

获取运行时类本身声明的所有的方法

Method[] m2 = clazz.getDeclaredMethods();
        for(Method m : m2){
            System.out.println(m);
        }

③获取 注解 权限修饰符 返回值类型 方法名 形参列表 异常

Method[] m2 = clazz.getDeclaredMethods();
        for(Method m : m2){
            //1.注解
            Annotation[] ann = m.getAnnotations();
            for(Annotation a : ann){
                System.out.println(a);
            }
            
            //2.权限修饰符
            String str = Modifier.toString(m.getModifiers());
            System.out.print(str + " ");
            //3.返回值类型
            Class returnType = m.getReturnType();
            System.out.print(returnType.getName() + " ");
            //4.方法名
            System.out.print(m.getName() + " ");
            
            //5.形参列表
            System.out.print("(");
            Class[] params = m.getParameterTypes();
            for(int i = 0;i < params.length;i++){
                System.out.print(params[i].getName() + " args-" + i + " ");
            }
            System.out.print(")");
            
            //6.异常类型
            Class[] exps = m.getExceptionTypes();
            if(exps.length != 0){
                System.out.print("throws ");
            }
            for(int i = 0;i < exps.length;i++){
                System.out.print(exps[i].getName() + " ");
            }
            System.out.println();
        }

④调用运行时类中指定的方法

Class clazz = Person.class;
        //getMethod(String methodName,Class ... params):获取运行时类中声明为public的指定的方法
        Method m1 = clazz.getMethod("show");
        Person p = (Person)clazz.newInstance();
        //调用指定的方法：Object invoke(Object obj,Object ... obj)

            注 :   'returnVal' 为方法返回值
        Object returnVal = m1.invoke(p);//我是一个人

        //无返回值
        System.out.println(returnVal);//null
        
        Method m2 = clazz.getMethod("toString");
        Object returnVal1 = m2.invoke(p);

          //打印返回值
        System.out.println(returnVal1);//Person [name=null, age=0]
        //对于运行时类中静态方法的调用
        Method m3 = clazz.getMethod("info");
        m3.invoke(Person.class);
        
        //getDeclaredMethod(String methodName,Class ... params):获取运行时类中声明了的指定的方法
 
注 : `其中 display 为private 修饰方法`
        Method m4 = clazz.getDeclaredMethod("display",String.class,Integer.class);
        m4.setAccessible(true);
        Object value = m4.invoke(p,"CHN",10);//我的国籍是：CHN
        System.out.println(value);//10

⑤获取所有构造器

public void test2() throws ClassNotFoundException{
       String className = "com.atguigu.java.Person";
       Class clazz = Class.forName(className);
       
       Constructor[] cons = clazz.getDeclaredConstructors();
       for(Constructor c : cons){
           System.out.println(c);
       }
   }

⑥获取父类

@Test
    public void test1(){
        Class clazz = Person.class;
        Class superClass = clazz.getSuperclass();
        System.out.println(superClass);
    }

⑦获取带着泛型的父类

public void test2(){
        Class clazz = Person.class;
        Type type1 = clazz.getGenericSuperclass();
        System.out.println(type1);
    }

⑧获取父类的泛型

public void test3(){
        Class clazz = Person.class;
        Type type1 = clazz.getGenericSuperclass();
        
        ParameterizedType param = (ParameterizedType)type1;
        Type[] ars = param.getActualTypeArguments();
        
        System.out.println(((Class)ars[0]).getName());
    }

⑨获取实现的接口

public void test4(){
        Class clazz = Person.class;
        Class[] interfaces = clazz.getInterfaces();
        for(Class i : interfaces){
            System.out.println(i);
        }
    }

⑩获取所在的包

public void test5(){
        Class clazz = Person.class;
        Package pack = clazz.getPackage();
        System.out.println(pack);
    }

11.获取注解

public void test6(){
        Class clazz = Person.class;
        Annotation[] anns = clazz.getAnnotations();
        for(Annotation a : anns){
            System.out.println(a);
        }
    }

12.调用指定的构造器

调用 private Person(String name,int age)这个构造器

public void test3() throws Exception{
        String className = "com.atguigu.java.Person";
        Class clazz = Class.forName(className);
        
        Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
        cons.setAccessible(true);
        Person p = (Person)cons.newInstance("TZ",20);
        System.out.println(p);
    }