java语法-反射

package reflect;

import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        // 反射机制
        // 各种框架的实现原理
        // 执行时 动态获取类的信息 操作对象
        // 描述类的类 Class
        // 获取类对象
        Class objClass = String.class;
        Class objClass1 = new Object().getClass();
        Class objClass2 = Class.forName("java.lang.Object");
//        Class objClass3 = Object.class.getClassLoader().loadClass("java.lang.Object");

        // 无Declared 只获得public修饰
//        // 获取构造器
//        for (Constructor constructor : objClass.getDeclaredConstructors()) {
//            System.out.println(constructor);
//        }
//        System.out.println("-----");
//        // 获取属性
//        for (Field declaredField : objClass.getDeclaredFields()) {
//            System.out.println(declaredField);
//            // 获取修饰符
//            int modifiers = declaredField.getModifiers();
//            // 获得类型
//            Class type = declaredField.getType();
//            // 属性名
//            String name = declaredField.getName();
//            // 注解
//            Annotation[] anos = declaredField.getDeclaredAnnotations();
//        }
//        System.out.println("-----");
//        // 获取方法
//        for (Method declaredMethod : objClass.getDeclaredMethods()) {
//            System.out.println(declaredMethod);
//            // 获取参数
//            Parameter[] parameters = declaredMethod.getParameters();
//            // 返回值类型
//            Class returnType = declaredMethod.getReturnType();
//            // 参数注解
//            Annotation[][] parameterAnnotations = declaredMethod.getParameterAnnotations();
//            // 异常
//            Class[] exceptionTypes = declaredMethod.getExceptionTypes();
//        }
//        System.out.println("-----");
//        // 获取实现接口
//        for (Class anInterface : objClass.getInterfaces()) {
//            System.out.println(anInterface);
//        }
//        System.out.println("-----");
        // 父类
//        Class superclass = objClass.getSuperclass();
//        Type genericSuperclass = objClass.getGenericSuperclass();
//        ParameterizedType genericSuperclass1 = (ParameterizedType) genericSuperclass;
//        // 父类泛型的类型
//        Type[] actualTypeArguments = genericSuperclass1.getActualTypeArguments();
        // 包
//        Package aPackage = objClass.getPackage();
        // 泛型
//        for (Field declaredField : MyClass.class.getDeclaredFields()) {
//            System.out.println(declaredField);
//            Type genericType = declaredField.getGenericType();
//            System.out.println(genericType);
//        }

        // 反射创建对象
        Constructor c = objClass.getDeclaredConstructor(String.class);
        String s = (String) c.newInstance("hello");
        System.out.println(s);
        // 反射访问属性
        Field value = objClass.getDeclaredField("value");
            // 获取权限
        value.setAccessible(true);
        value.set(s,value.get("world"));
        System.out.println(s);
        // 反射调用方法
        Method m = objClass.getDeclaredMethod("toString");
        m.setAccessible(true);
        String res = (String) m.invoke("haha");
        System.out.println(res);

        // java命令将类字节码文件加载到jvm
        // 加载的类 运行时类为Class实例
        // 运行时类是本体 对象是本体的分身

        // Class对象
        // 类 接口 数组 枚举 注解 基本数据类型 空

        // 类加载
        // 类加载器 将字节码文件读入内存
        // 链接 创建类对象内存结构，默认赋值
        // 初始化 类构造器 显式赋值和静态代码块初始化

        // 类加载器
        // 引导类加载器 扩展类加载器 系统类加载器
        // 引导类加载器 c++编写 核心类加载 如ObjectString
        // 扩展类加载器 加载jre下的lib包
        // 系统类加载器 加载类路径下的类
        // 类所在目录下资源文件
        System.out.println(ReflectTest.class.getClassLoader().getResource("1.txt"));
    }
}
class MyClass {
    T t;
    String s;
}