Java语法基础学习DayNineteen（反射机制）

一、Refection定义

1.概述

　　Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

2.功能

　　在运行时判断任意一个对象所属的类
　　在运行时构造任意一个类的对象
　　在运行时判断任意一个类所具有的成员变量和方法
　　在运行时调用任意一个对象的成员变量和方法
　　生成动态代理

3.反射相关的主要API

java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造方法

4.代码示例

import java.lang.reflect.Field;
import java.lang.reflect.Method;
public class Test{
    public static void main(String[] args) throws Exception{
        //有了反射，可以通过反射创建一个类的对象，并调用其中的结构
        Class<Person> clazz = Person.class;
        //1.创建clazz对应的运行时类Person类的对象
        Person p = (Person)clazz.newInstance();
        System.out.println(p);//Person[name=null,age=0]，属性为默认值
        //2.通过反射调用运行时类的指定的属性
        //2.1调用public属性
        Field f1 = clazz.getField("name");
        f1.set(p,"LiuDeHua");
        System.out.println(p);//Person[name=LiuDeHua,age=0]
        //2.2调用其他权限属性（private、default、protected）
        Field f2 = clazz.getDeclaredField("age");
        f2.setAccessible(true);
        f2.set(p, 20);
        System.out.println(p);//Person[name=LiuDeHua,age=20]
        //3.通过反射调用运行时类的指定的方法
        Method m1 = clazz.getMethod("show");
        m1.invoke(p);//我是一个人！
        Method m2 = clazz.getMethod("display",String.class);//有参数时要加上参数的运行时类
        m2.invoke(p,"CHN");//我的国籍是：CHN
    }
}

class Person{
    public String name;
    private int age;
    public void show(){
        System.out.println("我是一个人！");
    }
    public void display(String nation){
        System.out.println("我的国籍是："+nation);
    }
    public String toString(){
        return "Person[name="+name+",age="+age+"]";
    }
}

 二、Class类

1.概述

　　在Object类中定义了以下的方法，此方法将被所有子类继承：

　　public final Class getClass()

　　以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射求出类的名称。

     

2.特点

Class本身也是一个类

Class 对象只能由系统建立对象

一个类在 JVM 中只会有一个Class实例

一个Class对象对应的是一个加载到JVM中的一个.class文件

每个类的实例都会记得自己是由哪个 Class 实例所生成

通过Class可以完整地得到一个类中的完整结构

创建了任意一个类时，通过编译（javac.exe）,生成对应的.class文件。之后使用java.exe加载（JVM的类加载器完成的）
此.class文件，此.class文件加载到内存以后，就是一个运行时类，存在于缓存区。那么这个运行时类本身就是一个Class的实例！
每一个运行时类只加载一次！
有了Class的实例以后，我们才可以进行如下的操作：
　　1）创建对应的运行时类的对象
　　2）获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解、...）
　　3）调用对应的运行时类的指定的结构(属性、方法、构造器)
　　4）反射的应用：动态代理

 

3.常用方法

static Class forName(String name)：返回指定类名 name 的 Class 对象

Object newInstance()：调用缺省构造函数，返回该Class对象的一个实例

getName()：返回此Class对象所表示的实体（类、接口、数组类、基本类型或void）名称

Class [] getInterfaces()：获取当前Class对象的接口

ClassLoader getClassLoader()：返回该类的类加载器

Class getSuperclass()：返回表示此Class所表示的实体的超类的Class

Constructor[] getConstructors()：返回一个包含某些Constructor对象的数组

Field[] getDeclaredFields()：返回Field对象的一个数组

Method getMethod(String name,Class ... paramTypes)：返回一个名字为name的Method对象，此对象的形参类型为paramType

4.获取Class的实例的四种方法

public class Test{
    public static void main(String[] args) throws Exception{
        Test test = new Test();
        //1.调用运行时类本身的.class属性
        Class clazz1 = Person.class;
        System.out.println(clazz1.getName());//Person
        
        Class clazz2 = String.class;
        System.out.println(clazz2.getName());//java.lang.String
        
        //2.通过运行时类的对象获取
        Person p = new Person();
        Class clazz3 = p.getClass();
        System.out.println(clazz3.getName());//Person
        
        //3.通过Class的静态方法获取.通过此方式，体会一下，反射的动态性。
        String className = "Person";
        
        
        Class clazz4 = Class.forName(className);
//        clazz4.newInstance();
        System.out.println(clazz4.getName());//Person
        
        //4.（了解）通过类的加载器
        ClassLoader classLoader = test.getClass().getClassLoader();
        Class clazz5 = classLoader.loadClass(className);
        System.out.println(clazz5.getName());//Person
        
        System.out.println(clazz1 == clazz3);//true
        System.out.println(clazz1 == clazz4);//true
        System.out.println(clazz1 == clazz5);//true
    }
}

三、创建类对象并获取类的完整结构

1.创建运行时类的对象，使用newInstance()

        String className = "Person";
        Class clazz = Class.forName(className);
        //创建对应的运行时类的对象。使用newInstance()，实际上就是调用了运行时类的空参的构造器。
        //要想能够创建成功：①要求对应的运行时类要有空参的构造器。②构造器的权限修饰符的权限要足够。
        Object obj = clazz.newInstance();
        Person p = (Person)obj;
        System.out.println(p);//Person[name=null,age=0]

2.获取对应的运行时类的属性

public class Test{
    public static void main(String[] args) throws Exception{
        Class clazz = Person.class;
        //1.getFields():只能获取到运行时类中及其父类中声明为public的属性
        Field[] fields = clazz.getFields();
        for(int i = 0;i < fields.length;i++){
            System.out.println(fields[i]);//public java.lang.String Person.name
                                          //public double Creature.weight
        }
        System.out.println();
        //2.getDeclaredFields():获取运行时类本身声明的所有的属性
        Field[] fields1 = clazz.getDeclaredFields();
        for(Field f : fields1){
        //    System.out.println(f.getName());只获取属性名
        //1.获取每个属性的权限修饰符，public=1;private=2;default=0，需要使用Modifier的toString方法
            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 java.lang.String name
            //      private int age
            //       int id
        }
    }
}

public Person extends Creature{
    public String name;
    private int age;
    int id;
}

 

3.获取运行时类的方法

public class Test{
    public static void main(String[] args) throws Exception{
        Class clazz = Person.class;
        //1.getMethods():获取运行时类及其父类中所有的声明为public的方法（包括Object的方法）
        Method[] m1 = clazz.getMethods();
        for(Method m : m1){
            System.out.println(m);
        }
        System.out.println();    
        //2.getDeclaredMethods():获取运行时类本身声明的所有的方法
        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();
        }
    }
}

4.获取运行时类的构造器及其他

public class Test{
    public static void main(String[] args) throws Exception{
        String className = "Person";
        Class clazz = Class.forName(className);
        //1.获取运行时类自身所有构造器
        Constructor[] cons = clazz.getDeclaredConstructors();
        for(Constructor c : cons){
            System.out.println(c);
            //private Person(java.lang.String,int)
            //public Person(java.lang.String)
            //public Person()
        }
        //2.获取运行时类的父类
        Class superClass = clazz.getSuperclass();
        System.out.println(superClass);//class Creature
        //3.获取带泛型的父类
        Type type1 = clazz.getGenericSuperclass();
        System.out.println(type1);//Creature<java.lang.String>
        //4*.获取父类的泛型
        Type type2 = clazz.getGenericSuperclass();
        ParameterizedType param = (ParameterizedType)type2;
        Type[] ars = param.getActualTypeArguments();    
        System.out.println(((Class)ars[0]).getName());//java.lang.String
        //5.获取实现的接口
        Class[] interfaces = clazz.getInterfaces();
        for(Class i : interfaces){
            System.out.println(i);
            //interface java.lang.Comparable
            //interface MyInterface
        }
        //6.获取所在的包
        Package pack = clazz.getPackage();
        System.out.println(pack);//null
        //7.获取注解（生命周期为RUNTIME的注解才行）
        Annotation[] anns = clazz.getAnnotations();
        for(Annotation a : anns){
            System.out.println(a);//@MyAnnotation(value=victory)
        }
    }
}

 四、调用指定的属性、方法、构造器

1.调用运行时类中指定的属性

public class Test{
    public static void main(String[] args) throws Exception{
        Class clazz = Person.class;
        //1.获取指定的属性
        //getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性
        Field name = clazz.getField("name");
        //2.创建运行时类的对象 
        Person p = (Person)clazz.newInstance();
        System.out.println(p);//Person [name=null, age=0]
        //3.将运行时类的指定的属性赋值
        name.set(p,"Jerry");
        System.out.println(p);//Person [name=Jerry, age=0]
        System.out.println("%"+name.get(p));//%Jerry
        
        System.out.println();
        //getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性
        Field age = clazz.getDeclaredField("age");
        //由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。
        age.setAccessible(true);
        age.set(p,10);
        System.out.println(p);//Person [name=Jerry, age=10]
    }
}

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

public class Test{
    public static void main(String[] args) throws Exception{
        Class<Person> 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)
        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):获取运行时类中声明了的指定的方法
        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
    }
}

3.调用指定的构造器，创建运行时类的对象

public class Test{
    public static void main(String[] args) throws Exception{
        Class<Person> clazz = Person.class;
        
        Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
        cons.setAccessible(true);
        Person p = (Person)cons.newInstance("罗伟",20);
        System.out.println(p);//Person [name=罗伟, age=20]
    }
}