学习笔记之反射

反射

类加载器

类加载

当程序要使用某个类时,如果该类还未被加载到内存中,则系统会通过类得加载,类的连接,类的初始化这三个步骤来对类进行初始化,如果不出现意外情况,JVM将会连续完成这三个步骤,所以有时也把这三个步骤统称为类加载或类初始化

  1. 类加载:

    • 就是将class文件读入内存,并为之创建一个java.lang.Class对象
    • 任何类被使用时,系统都会为之创建一个java.lang.Class对象
  2. 类的连接

    • 验证阶段:用于检测被类加载的类是否具有正确的内部结构,并和其他类协调一致
    • 准备阶段:负责为类的类变量分配内存,并设置默认初始值
    • 解析阶段:将类的二进制数据中的符号引用替换为直接引用
  3. 类的初始化

    • 在该阶段,主要对类变量进行初始化
  • 类初始化步骤
    • 假如类还未被加载和连接,则程序先加载并连接该类
    • 假如该类的直接父类还未被初始化,则先初始化直接父类
    • 假如类中有初始化语句,则系统依次执行这些初始化语句

在执行第二个步骤时,系统对直接父类的初始化步骤也遵循初始化步骤1-3

  • 类的初始化时机:
    • 创建类的实例
    • 调用类的类方法
    • 访问类或者接口变量,或者为该类变量赋值
    • 使用反射方式来强制创建某个类或者接口对应的java.lang.Class对象
    • 初始化某个类的子类
    • 直接使用java.exe命令来运行某个主类
类加载器

作用:

  • 负责将.class文件加载到内存中,并为之生成对应的java.lang.Class对象
  • 虽然我们不过分关系类加载机制,但是了解这个机制我们就能更好的理解程序的运行

JVM的类加载机制:

  • 全盘负责:就是当一个类加载器负责加载某个Class时,该Class所依赖的和引用的其他Class也将由该类加载器负责载入,除非显示使用另外一个类加载器来载入
  • 父类委托:就是当一个类加载器负责加载某个Class时,先让父类加载器试图加载该Class对象时,只有在父类加载器无法加载类时才尝试从自己的路径中加载该类
  • 缓存机制:保证所有加载过的Class都会被缓存,当程序需要使用某个Class对象时,类加载器先从缓存区中搜索该Class,只有当缓存区中不存在该Class对象时,系统才会读取该类对应的二进制数据,并将其转换成Class对象,存储到缓存区
ClassLoader:是负责加载类的对象

java运行时具有以下内置类加载器

  • Bootstrap class loader:它是虚拟机的内置类加载器,通常表示为null,并且没有父类null
  • Platform class loader 。 平台类加载器可以看到所有平台类 ,可以将其用作ClassLoader实例的父ClassLoader 。 平台类包括由平台类加载器或其祖先定义的Java SE平台API,其实现类和JDK特定的运行时类。
  • System class loader 。 它也被称为应用程序类加载器 ,与平台类加载器不同。 系统类加载器通常用于定义应用程序类路径,模块路径和JDK特定工具上的类。

类加载器的继承关系:System的父加载器为Platform,而Platform得父加载器为Bootstrap

ClassLoader中得两个方法

  • static ClassLoader getSystemClassLoader():返回用于委派得系统类加载器
  • ClassLoader getParent():返回父类加载器进行委派

public class Demo {
    public static void main(String[] args) {
        //系统类加载器
        ClassLoader c = ClassLoader.getSystemClassLoader();
        System.out.println(c); //AppClassLoader

        //系统类加载器得父类加载器
        ClassLoader c2 = c.getParent();
        System.out.println(c2);//PlatformClassLoader

        ClassLoader c3 = c2.getParent();
        System.out.println(c3);//null     Bootstrap类加载器通常表示为null
    }
}

反射

java反射机制:是指在运行时去获取一个类得变量和方法信息。然后通过获取到得信息来创建对象,调用方法得一种机制。由于这种动态性,可以极大得增强程序得灵活性,程序不用在编译期就完成确定,在运行期仍然可以扩展。

获取Class类得对象

想要用过反射去使用一个类,首先要获取到该类的字节码文件对象,也就是类型为Class类型的对象。

获取Calss类型对象的三种方式

  • 使用类的class属性来获取该类对应的Class对象。例如:Student.class将会返回Student类对应的Class对象
  • 调用对象的getClass()方法,返回该对象所属类对应的Class对象
    • 该方法时Object类中的方法,所有的Java对象都可以调用该方法
  • 使用Class类中的静态方法forName(String className),该方法需要传入字符串参数,该字符串参数的值是某个类的全路径,也就是完整包名的路径
public class Student {
    //成员变量:一私,一默认,一公
    private String name;
    int age;
    public String address;

    //构造方法:一公,一私,一默认
    public Student() {
    }

    private Student(String name) {
        this.name = name;
    }

    Student(int age, String address) {
        this.age = age;
        this.address = address;
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员方法:一个私有,四公
    private void function() {
        System.out.println("function");
    }

    public void method1() {
        System.out.println("method");
    }

    public void method2(String s) {
        System.out.println("method" + s);
    }

    public String method3(String s, int i){
        return s + "," + i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}
public class Demo {
    public static void main(String[] args) throws ClassNotFoundException {
        //使用类的class属性来获取该类对应的Class对象。
        Class c1 = Student.class;
        System.out.println(c1);

        Class c2 = Student.class;
        System.out.println(c1 == c2);
        System.out.println("--------------");

        //调用对象的getClass()方法,返回该对象所属类对应的Class对象
        Student s = new Student();
        Class c3 = s.getClass();
        System.out.println(c1 == c3);
        System.out.println("--------------");

        //使用Class类中的静态方法forName(String className)
        Class c4 = Class.forName("反射.获取Class对象的三种方式.Student");//package 反射.获取Class对象的三种方式;//最灵活
        System.out.println(c1 == c4);
    }
}

反射获取构造方法并使用
public class Student {
    //成员变量:一私,一默认,一公
    private String name;
    int age;
    public String address;

    //构造方法:一公,一私,一默认
    public Student() {
    }

    private Student(String name) {
        this.name = name;
    }

    Student(int age, String address) {
        this.age = age;
        this.address = address;
    }

    public Student(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    //成员方法:一个私有,四公
    private void function() {
        System.out.println("function");
    }

    public void method1() {
        System.out.println("method");
    }

    public void method2(String s) {
        System.out.println("method" + s);
    }

    public String method3(String s, int i){
        return s + "," + i;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
}

Class类中用于获取构造方法的方法

  1. getConstructors​() 返回一个包含 Constructor对象的数组
import java.lang.reflect.Constructor;

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Constructor[] cons = c.getConstructors();
        for (Constructor con : cons){
            System.out.println(con);
        }
    }
}

  1. Constructor[] getDeclaredConstructors​():返回所有构造方法对象的数组
import java.lang.reflect.Constructor;
public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con : cons){
            System.out.println(con);
        }
    }
}

  1. Constructor getConstructor​(Class.. .parameterTypes):返回单个公共构造方法
  • Constuructor 类中用于创建对象的方法
    • T newInstance​(Object... initargs):根据指定的构造方法创建对象
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);
    }
}

  1. Constructor getDeclaredConstructor​(Class... parameterTypes):返回单个构造方法对象
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Constructor con = c.getDeclaredConstructor();
        Object obj = con.newInstance();
        System.out.println(obj);
    }
}
练习1

通过反射实现

  • Student s = new Student("张三",18,"广东")
  • System.out.println(s)
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");

        //public Student(String name, int age, String address)
        Constructor con = c.getConstructor(String.class, int.class, String.class);//基本数据类型也可以通过.class得到
        Object obj = con.newInstance("张三", 18, "广东");
        System.out.println(obj);
    }
}

练习2
  • Student s = new Student("张三")
  • System.out.println(s)
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");

        // private Student(String name)  私有无法创建对象需要暴力反射
        Constructor con = c.getDeclaredConstructor(String.class);

        //暴力反射
        //public void setAccessible (boolean flag):值为true,取消访问检测
        con.setAccessible(true);

        Object obj = con.newInstance("张三");
        System.out.println(obj);
    }
}

反射成员变量并使用

获取成员变量的四个方法

  1. Field[] getFields​():返回所有公共成员变量的数组
import java.lang.reflect.Field;
public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Field[] fields = c.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
    }
}


  1. Field[] getDeclaredFields​():返回所有成员变量对象的数组
import java.lang.reflect.Field;
public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Field[] fields = c.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
    }
}

  1. Field getField​(String name)返回单个公共成员变量对象
  • Field类中用于给成员变量赋值的方法
    • void set​(Object obj, Object value):给obj对象的成员变量赋值为value
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Field field = c.getField("address");
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
        field.set(obj, "西安");//给obj的成员变量addressfield赋值
        System.out.println(obj);
    }
}

  1. Field getDeclaredField​(String name):返回单个成员变量对象
  • Field类中用于给成员变量赋值的方法
    • void set​(Object obj, Object value):给obj对象的成员变量赋值为value
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Field field = c.getDeclaredField("address");

        Constructor con = c.getConstructor();
        Object obj = con.newInstance();
        field.set(obj,"西安");//给obj的成员变量addressfield赋值
        System.out.println(obj);
    }
}
练习1

用反射

  • Student s = new Student()
  • s.name = "张三"
  • s.age = "18"
  • s.address = "西安"
  • System.out.println(s)
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");

        //* Student s = new Student()
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        // * s.name = "张三"
        Field nameField = c.getDeclaredField("name");
        nameField.setAccessible(true);
        nameField.set(obj,"张三");

        // * s.age = "18"
        Field ageField = c.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(obj,18);

        //* s.address = "西安"
        Field addressField = c.getDeclaredField("address");
        addressField.set(obj,"西安");

        System.out.println(obj);
    }
}

反射获取成员方法并使用

获取成员方法的方法

  1. Method[] getMethods​():返回所有公共成员方法对象的数组,包括继承的
import java.lang.reflect.Method;

public class Demo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Method[] methods = c.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

  1. Method[] getDeclaredMethods​():返回所有成员方法对象的数组,不包括继承的
import java.lang.reflect.Method;

public class Demo2 {
    public static void main(String[] args) throws ClassNotFoundException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

  1. Method getMethod​(String name, Class... parameterTypes):返回单个共有成员方法对象
  • Method类中用于调用成员方法的方法
    • Object invoke​(Object obj, Object... args):调用obj对象的成员方法,参数是args,返回值是Object类型
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo3 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");

        //创建对象
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        Method m = c.getMethod("method1");
        m.invoke(obj);
    }
}

  1. Method getDeclaredMethod​(String name, Class... parameterTypes):返回单个成员方法
  • Method类中用于调用成员方法的方法
    • Object invoke​(Object obj, Object... args):调用obj对象的成员方法,参数是args,返回值是Object类型
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //获取Class对象
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");

        //创建对象
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        Method m = c.getDeclaredMethod("function");
        m.setAccessible(true);
        m.invoke(obj);
    }
}

练习
  • Student s = new Student();
  • s.method1()
  • s.method2("张三")
  • String ss = s.method3("张三",20)
  • System.out.print(ss)
  • s.function()
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class c = Class.forName("反射.获取Class对象的三种方式.Student");

        //Student s = new Student();
        Constructor con = c.getConstructor();
        Object obj = con.newInstance();

        //s.method1()
        Method m1 = c.getMethod("method1");
        m1.invoke(obj);
        System.out.println("--------------");

        //s.method2("张三")
        Method m2 = c.getMethod("method2", String.class);
        m2.invoke(obj,"张三");
        System.out.println("--------------");

        //String ss = s.method3("张三",20)
        Method m3 = c.getMethod("method3", String.class, int.class);
        Object ss = m3.invoke(obj, "张三", 20);
        //System.out.print(ss)
        System.out.println(ss);
        System.out.println("--------------");

        //s.function()
        Method m4 = c.getDeclaredMethod("function");
        m4.setAccessible(true);
        m4.invoke(obj);
    }
}

反射练习

  1. 有一个ArrayList 集合,现在我想在这个集合中添加一个字符串数据如何实现?
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class Demo {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        ArrayList array = new ArrayList();

        Class c = array.getClass();
        Method m = c.getDeclaredMethod("add", Object.class);

        m.invoke(array, "hello");
        m.invoke(array, "world");
        m.setAccessible(true);
        array.add(10);
        System.out.println(array);
    }
}

  1. 通过配置文件运行类中的方法

class.txt:

className = 反射.练习运行配置文件指定内容.Student
methodName = study
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

public class Demo {
    public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //开始
//        Student s = new Student();
//        s.study();

        //现在要改成
//        Teacher t = new Teacher();
//        t.teach();

        //需要来回修改灵活性不高

        /*
        class.txt
        className = xxx
        methodName = xxx
         */

        //加载数据
        Properties prop = new Properties();
        FileReader fr = new FileReader("反射\\class.txt");
        prop.load(fr);
        fr.close();
        /*
        className = 反射.练习运行配置文件指定内容.Student
        methodName = study
         */
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        Class c = Class.forName(className);
        Object obj = c.getConstructor().newInstance();

        Method m = c.getMethod(methodName);
        m.invoke(obj);
    }
}

你可能感兴趣的:(学习笔记之反射)