public class Test {
	String name;
	public void say(){
		System.out.println("Hello Word");
	}
	
	// 程序的入口的方法，和具体类无关
	public static void main(String[] args) {
		Test t = new Test();	
		t.say();
		// 得到当前的类加载器ApplicationClassLoader
		ClassLoader cl = Test.class.getClassLoader();
		System.out.println(cl);
		// 得到ApplicationClassLoader的父类加载器ExtensionClassLoader
		ClassLoader extCl = cl.getParent();
		System.out.println(extCl);
		// 得到ExtensionClassLoader的父类加载器BootstrapClassLoader
		// 由于BootstrapClassLoader是用C/C++语言编写的，在java中无法直接使用
		// 所以才会返回一个null
		ClassLoader bootCl = extCl.getParent();
		System.out.println(bootCl);
	}
}

String s = new String();

private Class(ClassLoader loader) {
    classLoader = loader;
}

// 类名.class  通过获取类的静态成员变量class得到(任何类都有一个隐含的静态成员变量class)
Class<?> clazz = String.class;
// 对象.getClass
Class<?> clazz2 = new String().getClass();
// Class.forName("全量限定名")
Class<?> clazz3 = Class.forName("java.lang.String");

getField() // 获取所有公开的属性字段（包括继承父类的公有属性）
getDeclaredField() // 获取本类所有（包括公有和私有，但是不包括父类的）的属性字段（注意：如果要访问和操作私有属性，必须调用setAccessible方法，打开访问开关）
getFields() // 获取所有公有的属性（包括继承自父类的公有属性）
getDeclaredFields() // 获取本类所有的属性（包括共有和私有的，但是不包括父类的）
set() // 给属性赋值，需要传入两个参数，第一个参数是当前类的一个实例，第二个参数是具体要赋予的值
get() // 获取属性的值，需要传入一个当前类的实例作为参数
getName() // 获取属性的名称
getType() // 获取属性的类型
isAnnotationPresent() // 判断该属性上是否定义了指定的注解，需要传入一个注解的Class对象作为参数
getAnnotation() // 获取当前属性上的注解对象，需要传入一个注解的Class对象作为参数

public static void main(String[] args) throws Exception {
     
    // 在反射操作之前的第一步，就是要先获取Class对象
    Class<?> clazz = Class.forName("org.demo.reflect.bean.People");
    // 根据Class对象创建一个实例
    Object instance = clazz.newInstance();
    // 获取指定的属性
    Field f1 = clazz.getField("userName");
    // 获取属性的值,get方法需要传入一个当前类的实例
    Object value = f1.get(instance);
    System.out.println(value);
    // 通过反射给属性赋值
    // 第一个参数是当前类的实例，第二个参数是要赋予的值
    f1.set(instance, "godql");
    value = f1.get(instance);
    System.out.println(value);
    // 获取一个私有的属性
    // 如果需要访问和操作私有的成员，必须打开访问开关
    // 打开访问开关其实就是破坏封装
    Field f2 = clazz.getDeclaredField("age");
    // 强制打开访问权限
    f2.setAccessible(true);
    Object value2 = f2.get(instance);
    System.out.println(value2);
    f2.set(instance, 30);
    value2 = f2.get(instance);
    System.out.println(value2);
    // 获取属性的名称
    System.out.println(f1.getName());
    System.out.println(f2.getName());
    // 获取属性的类型
    System.out.println(f1.getType());
    System.out.println(f2.getType());
    // 获取所有公有的属性(包括继承自父类的公有属性)
    Field[] fs1 = clazz.getFields();
    // 获取本类所有的属性（包括共有和私有的，但是不包括父类的）
    Field[] fs2 = clazz.getDeclaredFields();
    // 判断当前属性上是否定义了注解
    System.out.println(f1.isAnnotationPresent(MyAnno.class));
    ystem.out.println(f2.isAnnotationPresent(MyAnno.class));
    // 获取属性上定义的注解
    MyAnno anno = f1.getAnnotation(MyAnno.class);
    // 获取注解上的属性值
    System.out.println(anno.name());
}

getMethod() // 获取指定的公共的方法（包括继承自父类公共的），需要传递两个参数，第一个参数是方法名称，第二个参数是一个可变参数，传递的是方法参数的类型
getMethods() // 获取所有的公共的方法（包括继承父类的公共方法）。
getDeclaredMethod() // 获取本类中指定的方法（包括私有和共有的，不包括父类的），需要传递两个参数，第一个参数是方法名称，第二个参数是一个可变参数，传递的是方法参数的类型。如果是私有方法，同样需要先打开访问开关(setAccessible(true))。
getDeclaredMethods() // 获取本地中所有的方法（包括私有和公共的，不包括父类）
getName() // 获取方法名称
getReturnType() // 获取方法的返回值类型
getParameterTypes() // 获取方法中所有的参数类型
getParameterCount()// 获取方法中参数的总个数
getParameters() // (JDK1.8新特性)获取方法中所有的参数信息，每一个参数信息都是一个Parameter类的对象。可以通过这个对象获取各个参数的类型以及名称(注意：如果要获取参数名，在编译的时候需要加上一个parameters参数，如：javac -parameters Xxx.java。或者是在开发环境中设置相应的编译选项)。
invoke() // 回调当前方法,需要传递两个参数，第一个是当前类的实例，第二个是一个可变参数，需要传入调用方法是所需的参数值。

public static void main(String[] args) throws Exception {
     
    Class<?> clazz = Class.forName("org.demo.reflect.bean.People");
    Object instance = clazz.newInstance();
    // 获取指定的Method
    Method m1 = clazz.getMethod("say", String.class, int.class);
    // 获取方法名
    System.out.println(m1.getName());
    // 获取方法的返回值类型
    System.out.println(m1.getReturnType());
    // 获取方法的所有参数类型
    Class<?>[] paramsType = m1.getParameterTypes();
    for (Class<?> c : paramsType) {
        System.out.println(c);
    }
    // 获取参数名称（JDK1.8开始支持）
    Parameter[] params = m1.getParameters();
    for (Parameter p : params) {
        System.out.println("参数类型:"+p.getType());
        System.out.println("参数名称:"+p.getName());
    }
    // 通过当前的方法，获取定义这个方法的类
    Class<?> c = m1.getDeclaringClass();
    System.out.println(c.getName());
  
    // 方法回调，目的就是通过反射去调用一个方法
    m1.invoke(instance, "godql", 21);
}

getConstructor() // 获取无参并且公共的构造方法
getDeclaredConstructor() // 获取一个构造方法可以是私有的也可以是公共的，需要传入一个可变参数，就是构造方法的参数类型（注意：如果是私有的，必须先打开访问开关）
newInstance() // 通过构造方法创建实例，也需要传入一个可变参数，传入的是具体的值
getConstructors() // 获取所有公共的构造方法，返回的是一个Constructor数组
getDeclaredConstructors() // 获取所有的构造方法(包括私有和共有的),同样返回的是一个数组
getParameters() // 获取所有的参数对象，和Method一样
getParameterTypes() // 获取所有的参数类型，同Method一样

public static void main(String[] args) throws Exception {
      
    Class<?> clazz = People.class;
    // 获取无参的构造方法
    Constructor<?> c1 = clazz.getConstructor();
    // 获取构造方法的名称
    System.out.println(c1.getName());
    // 获取一个私有并且带参数的构造方法
    Constructor<?> c2 = clazz.getDeclaredConstructor(String.class);
  
    // 可以通过构造方法实例化一个对象
    //（注意：如果默认有一个无参并且是公共的构造方法，
    // 那么可以直接使用class.newInstance()方法创建实例，
    // 如果构造方法是私有的，或者是带参数的，就必须先获取
    // Constructor对象，在通过这个对象来创建类实例）
  
    // 1.适用于无参并且是公共的构造方法
    /* 
      Object instance = clazz.newInstance();
      System.out.println(instance);
    */
  
    // 2.适用于带参数或是私有的构造方法
    // 由于构造方法也可以私有化，所以必须先打开访问开关
    c2.setAccessible(true);
    Object instance = c2.newInstance("godql");
    System.out.println(instance);
  
    // 获取所有public修饰的构造方法
    Constructor<?>[] cons = clazz.getConstructors();
    // 获取所有构造方法（包括私有的）
    Constructor<?>[] cons2 = clazz.getDeclaredConstructors();
}

getPackage() // 获取当前类所在的包，使用Package对象进行封装，可以从中获取包的信息，例如：包名
getSimpleName() // 获取当前类的简单类名（不包括包名）
getName() // 获取当前类的完整类名(包括包名)
getSuperclass() // 获取当前类的父类，返回的也是一个Class对象
getInterfaces() // 获取当前类所实现的所有接口，返回的是一个Class数组
isAnnotationPresent() // 判断当前类上是否定义了注解
getAnnotation() // 获取类上定义的注解

public static void main(String[] args) {
     
    List list = new ArrayList(); 
    List<String> list1 = new ArrayList<>(); 
   
    list.add("godql");
    // list1.add(20); 错误的
    Class c1 = list.getClass();
    Class c2 = list1.getClass();
   
    System.out.println(c1 == c2); // 结果：true，说明类类型完全相同
    // 反射的操作都是编译之后的操作(运行时)
   
    /*
     * 以上说明编译之后集合的泛型是泛型擦除的
     * Java中集合的泛型，是防止错误输入的，只在编译阶段有效，绕过编译就无效了。
     * 验证: 通过方法的反射来操作，绕过编译 
     */
    try {
        // 通过动态操作方法的反射得到add方法
        Method m = c2.getMethod("add", Object.class);
        // 方法回调 给list1添加一个int型的，这是在运行时的操作，所以编译器编译时没有泛型检查，所以不会报错
        // 绕过编译操作
        m.invoke(list1, 20);
        // 验证是否有添加进list集合里
        System.out.println(list1.size()); 
        // 这时候不能使用foreach遍历，否则集合会认为集合里边全是String类型的值
        // 且有类型转换错误，因为这个集合里面有int类型、String类
        System.out.println(list1); 
    } catch (Exception e) {
           e.printStackTrace();
    }
}