一脚踩进java之基础篇48——反射

一、类的加载器

1.1 类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三步来实现对这个类的初始化。

　　1）加载：是将class文件读入内存，并为之创建一个class对象，任何类被使用时系统都会建立一个class对象。

　　2）连接：

　　　　①验证：是否有正确的内部结构，并和其他类协调一致

　　　　②准备：负责为类的静态成员分配内存，并设置默认的初始化值

　　　　③解析：将类的二进制数据中的符号引用替换为直接引用

　　3）初始化：就是我们以前讲过的初始化步骤

1.2 类初始化时机

　1）创建类的实例

　2）类的静态变量，或者为静态变量赋值

　3）类的静态方法

　4）使用反射方式来强制创建某个类或者接口对应的java.lang.Class对象

　5）初始化某个类的字类

　6）直接使用java.exe命令来运行某个主类

 1.3 类加载器

　1）负责将.class文件加载到内存中，并为之生成相应的Class对象

　2）虽然我们不需要关心类加载机制，但是了解这个机制，我们能更好的理解程序的运行

1.4 类加载器的组成

　1）Bootstrap ClassLoader根类加载器

　　也被称为引导类加载器，负责java核心类的加载，比如System、String等。在JDK中的JRE的lib目录下rt.jar文件中

　2）Extension ClassLoader扩展类加载器

　　负责JRE的扩展目录中jar包的加载。在JDK中的JRE的ext目录。

　3）System ClassLoader系统类加载器

　　负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

二、反射

　　java反射机制时在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法；对于任意一个对象，都能调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

　　想要解剖一个类，必须先要取到该类的字节码文件对象。

2.1 Class类

　　阅读API的Class类得知Class没有公共的构造方法。Class对象是在加载类时由Java虚拟机以及通过调用类加载器中的defineClass方法自动构造的。

　　1）获取Class对象的三种方式

　　①通过Object类中的getClass方法

Person p = new Person();
Class c = p.getClass();

　　②通过类名.class获取到字节码文件对象（任意数据类型都具备一个class静态属性，看上去要比第一种方式简单）

Class c2 = Person.class;

　　③通过Class类的静态方法获取 forName(字符串的类名)包名.类名

Class c2 = Class.forName("com.hq.Person");

2.2 代码演示

　　Person类

public class Person {
    public String name;
    private int age;
    
    public Person(){
    }
    
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    
    private Person(int age,String name){
        this.name = name;
        this.age = age;
    }
    
    public void eat(){
        System.out.println("人吃饭");
    }

    public void sleep(String s, int a,double d){
        System.out.println("人在睡觉"+s+"....."+a+"....."+d);
    }
    private void playGame(){
        System.out.println("人在打游戏");
    }

    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    
}

　　1）通过反射获取class文件中的构造方法,运行构造方法

/*
 *  通过反射获取class文件中的构造方法,运行构造方法
 *  运行构造方法,创建对象
 *    获取class文件对象
 *    从class文件对象中,获取需要的成员
 *    
 *  Constructor 描述构造方法对象类
 */
public class ReflectDemo1 {
    public static void main(String[] args) throws Exception {
    
        Class c = Class.forName("com.ha.Person");
        //使用class文件对象,获取类中的构造方法
        //  Constructor[]  getConstructors() 获取class文件对象中的所有公共的构造方法
        /*Constructor[] cons = c.getConstructors();
        for(Constructor con : cons){
            System.out.println(con);
        }*/
        //获取指定的构造方法,空参数的构造方法
        Constructor con =  c.getConstructor();
        //运行空参数构造方法,Constructor类方法 newInstance()运行获取到的构造方法
        Object obj = con.newInstance();
        System.out.println(obj.toString());
    }
}

　　2）通过反射,获取有参数的构造方法并运行

/*
 *  通过反射,获取有参数的构造方法并运行
 *  方法getConstructor,传递可以构造方法相对应的参数列表即可
 */
public class ReflectDemo2 {
    public static void main(String[] args)throws Exception {
        Class c = Class.forName("com.hq.Person");
        //获取带有,String和int参数的构造方法
        //Constructor<T> getConstructor(Class<?>... parameterTypes)  
        //Class<?>... parameterTypes 传递要获取的构造方法的参数列表
        Constructor con = c.getConstructor(String.class,int.class);
        //运行构造方法
        // T newInstance(Object... initargs)  
        //Object... initargs 运行构造方法后,传递的实际参数
        Object obj = con.newInstance("张三",20);
        System.out.println(obj);
    }
}

　　3）反射获取构造方法并运行,有快捷点的方式

/*
 * 反射获取构造方法并运行,有快捷点的方式
 * 有前提:
 *   被反射的类,必须具有空参数构造方法
 *   构造方法权限必须public
 */
public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        Class c = Class.forName("cn.itcast.demo1.Person");
        // Class类中定义方法, T newInstance() 直接创建被反射类的对象实例
        Object obj = c.newInstance();
        System.out.println(obj);
    }
}

　　4）反射获取私有的构造方法运行

/*
 *  反射获取私有的构造方法运行
 *  不推荐,破坏了程序的封装性,安全性
 *  暴力反射
 */
public class ReflectDemo4 {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("com.hq.Person");
        //Constructor[] getDeclaredConstructors()获取所有的构造方法,包括私有的
        /*Constructor[] cons = c.getDeclaredConstructors();
        for(Constructor con : cons){
            System.out.println(con);
        }*/
        //Constructor getDeclaredConstructor(Class...c)获取到指定参数列表的构造方法
        Constructor con = c.getDeclaredConstructor(int.class,String.class);
        
        //Constructor类,父类AccessibleObject,定义方法setAccessible(boolean b)
        con.setAccessible(true);
        
        Object obj = con.newInstance(18,"lisi");
        System.out.println(obj);
    }
}

　　5）反射获取成员变量,并修改值

/*
 *  反射获取成员变量,并修改值
 *  Person类中的成员String name
 */
public class ReflectDemo5 {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("com.hq.Person");
        Object obj = c.newInstance();
        //获取成员变量 Class类的方法 getFields() class文件中的所有公共的成员变量
        //返回值是Field[]    Field类描述成员变量对象的类
        /*Field[] fields = c.getFields();
        for(Field f : fields){
            System.out.println(f);
        }*/
        
        //获取指定的成员变量 String name
        //Class类的方法  Field getField(传递字符串类型的变量名) 获取指定的成员变量
        Field field = c.getField("name");
       
        //Field类的方法 void set(Object obj, Object value) ,修改成员变量的值
        //Object obj 必须有对象的支持,  Object value 修改后的值
        field.set(obj,"王五");
        System.out.println(obj);
        
    }
}

　　6）反射获取成员方法并运行

/*
 *  反射获取成员方法并运行
 *  public void eat(){}
 */
public class ReflectDemo6 {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("com.hq.Person");
        Object obj = c.newInstance();
        //获取class对象中的成员方法
        // Method[] getMethods()获取的是class文件中的所有公共成员方法,包括继承的
        // Method类是描述成员方法的对象
        /*Method[] methods = c.getMethods();
        for(Method m : methods){
            System.out.println(m);
        }*/
        
        //获取指定的方法eat运行
        // Method getMethod(String methodName,Class...c)
        // methodName获取的方法名  c 方法的参数列表
        Method method = c.getMethod("eat");
        //使用Method类中的方法,运行获取到的方法eat
        //Object invoke(Object obj, Object...o)
        method.invoke(obj);
    }
}

　　7）反射获取有参数的成员方法并执行

/*
 *  反射获取有参数的成员方法并执行
 *  public void sleep(String,int,double){}
 */
public class ReflectDemo7 {
    public static void main(String[] args) throws Exception{
        Class c = Class.forName("cn.itcast.demo1.Person");
        Object obj = c.newInstance();
        //调用Class类的方法getMethod获取指定的方法sleep
        Method method = c.getMethod("sleep", String.class,int.class,double.class);
        //调用Method类的方法invoke运行sleep方法
        method.invoke(obj, "休眠",100,888.99);
    }
}

2.3 反射泛型擦除

1）定义集合类,泛型String，要求向集合中添加Integer类型

/*
 *   定义集合类,泛型String
 *   要求向集合中添加Integer类型
 *   
 *   反射方式,获取出集合ArrayList类的class文件对象
 *   通过class文件对象,调用add方法
 *   
 *   对反射调用方法是否理解
 */
public class ReflectTest {
    public static void main(String[] args)throws Exception {
        ArrayList<String> array  = new ArrayList<String>();
        array.add("a");
        //反射方式,获取出集合ArrayList类的class文件对象
        Class c = array.getClass();
        //获取ArrayList.class文件中的方法add
        Method method = c.getMethod("add",Object.class);
        //使用invoke运行ArrayList方法add
        method.invoke(array, 150);
        method.invoke(array, 1500);
        method.invoke(array, 15000);
        System.out.println(array);
        
        
    }
}