Java之反射理解

Java创建对象的几种方式

1. new关键字
2. 克隆（clone）
3. 反序列化
4. 反射

Java中获取类和对象信息有两种方法

1. RTTI(RunningTime Type Information)和反射机制
2. 区别：RTTI：编译器在编译时打开和检查.class文件。 反射：运行时打开和检查.class文件

反射

反射机制是Java运行中，对于任何一个类，都能知道这个类的属性和方法，对任何一个对象，都能调用这个对象的任意的方法和属性。
这种动态获取对象信息和调用对象方法的功能称为反射。

反射的使用方法

class类和reflect类库

1. getFiles,getMethods 获取所有public的属性,方法(含父类)
2. getDeclareFiles,getDeclareMethods 获取所有当前反射类的所有属性,方法
3. getDeclareConstructors 获取所有共有构造器(不含父类,因为构造器不能被继承)

class ：类的实体，在运行的Java应用程序表示类和接口
field ：类的成员变量（类的属性）
method ：类的方法
constructor ：类的构造器
反射机制基本就是根据以上类来输出需要的信息，以下是代码说明：

public class People {
    public People(){}
    public double height;
    public int gender;

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public int getGender() {
        return gender;
    }

    public void setGender(int gender) {
        this.gender = gender;
    }
}

实体people类

public class Student extends People{
    public String name;
    public int age;
    @Override
    public String toString() {
        return "student"+":name "+name+" age: "+age;
    }

    public Student(String name, int age) {
        setName(name);
        setAge(age);
    }

    public Student() {
        System.out.println("执行了构造方法");
    }

    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;
    }
}

子类student类

public class Test {
    public static void main(String[] args) {
        String classPath = "work1.Student";
        Student student = (Student)createInstance(classPath);
        student.setName("赵子龙");
        student.setAge(18);
        System.out.println(student);
        printer(classPath);
    }

    private static Object createInstance(String classPath) {
        try{
            Class<?> aClass = Class.forName(classPath);
            return aClass.newInstance();
        }catch (Exception e){
            e.printStackTrace();
        }
    return null;
    }
    public static void printer(String classPath){
        try{
            Class<?> cls = Class.forName(classPath);
            //获取这个字节码所有的public字段(含父类)(需要公有)
            Field[] myfields = cls.getFields();
            for (Field aa:myfields) {
                System.out.println(aa.getName());
            }
            //获取当前cls的所有字段(可以是公有也可以是私有)
            Field[] myfields1 = cls.getDeclaredFields();
            for (Field field: myfields1) {
                System.out.println(field.getName());
            }
            //获取所有public的方法(含父类)getMethods是包含父类,declaredMethods是当前类
            Method[] methods = cls.getDeclaredMethods();
            for(Method method:methods){
                System.out.println(method.getName());
            }
            //动态获取当前类的类名
            System.out.println(cls.getName());
            //获取构造器有多少个(当前类)
            Constructor<?>[] constructors = cls.getConstructors();
            System.out.println(constructors.length);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}

测试类Test，输出结果如下：
执行了构造方法
student:name 赵子龙 age: 18
name
age
height
gender
name
age
toString
getName
setName
getAge
setAge
work1.Student
2

public class TestObiect {
    public static void main(String[] args) throws Exception {
        Student student = new Student("kqlxxwd",20 );
        student.setGender(1);
        student.setHeight(170);
        String json = getJson(student);
        System.out.println(json);
    }

    private static String getJson(Object object) throws InvocationTargetException, IllegalAccessException {
        StringBuilder jsonStr = new StringBuilder("{");
        Class<?> aClass = object.getClass();
        //获取到所有的方法(含继承到的父类方法)
        Method[] methods = aClass.getMethods();
        //对象名.method()
        for (Method method: methods){
            if(method.getName().startsWith("get")){
                String jsonKey = method.getName().substring(3).toLowerCase();
                if(jsonKey.equals("class")) continue;
                String jsonValue = method.invoke(object).toString();
                jsonStr.append("\""+jsonKey+"\"");
                jsonStr.append(":");
                jsonStr.append("\""+jsonValue+"\"");
                jsonStr.append(",");
            }
        }
        jsonStr.deleteCharAt(jsonStr.length()-1);
        jsonStr.append("}");
        return jsonStr.toString();
    }
}

另一个测试类，输出对象信息的方法：
{“name”:“kqlxxwd”,“age”:“20”,“height”:“170.0”,“gender”:“1”}

类加载器

1. 类的加载过程：
   　　当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三步骤来实现对这个类进行初始化。
   　　加载：
   　　就是指将class文件读入内存，并为之创建一个Class对象。任何类使用时系统都会建立一个Class对象。
   　　连接：
   　验证，是否有正确的内部结构，并和其他类协调一致。
   　准备，负责为类的静态成员分配内存，并设置默认初始化值
   　解析，将类的二进制数据中的符号引用替换为直接引用
   　　初始化：
   　　开辟栈、堆内存空间，创建对象、默认初始化、显示初始化、构造初始化

2. 类加载器的主要作用：
   将.class文件加载到内存，并生成对应的Class对象

3. 类加载器的组成
   　　根类加载器：Bootstrap ClassLoader
   　　　　也称为引导类加载器，负责java核心类的加载。比如，System Object String等，在JDK中的JRE的lib目录下rt.jar文件中
   　　扩展类加载器：Extension ClassLoader
   　　　　JRE的扩展目录中jre包的加载
   　　系统类加载器:System ClassLoader
   　　　　在JVM启动时加载来自java命令的class文件以及classpath环境变量所指的jar包和类路径