java的反射机制（重要）

public class Student {
}

public class Reflect {
    public static void main(String[] args) {
        // (1)通过运行时类的对象，调用其getClass()方法
        Student stu1 = new Student();// 这一new 产生一个Student对象，一个Class对象。
        Class stuClass = stu1.getClass();// 获取Class对象
        System.out.println(stuClass.getName());

        // (2)调用运行时类的.class属性
        Class stuClass2 = Student.class;
        System.out.println(stuClass == stuClass2);// 判断第一种方式获取的Class对象和第二种方式获取的是否是同一个

        // (3)调用Class的静态方法forName(String className)。此方法报ClassNotFoundException
        try {
            Class stuClass3 = Class.forName("com.jp.Student");// 注意此字符串必须是真实路径
            System.out.println(stuClass3 == stuClass2);// 判断三种方式是否获取的是同一个Class对象
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

public class Student {
    int a = gg;//很明显错的
}

//方法一：Class的newInstanc()方法
@Test
  public void test1() throws Exception{
      Class clazz = Class.forName("com.jp.Animal");//拿到Class实例（即运行时类）
      Object obj = clazz.newInstance();
      Animal a = (Animal)obj;
      System.out.println(a);
  }

//方法二：Class的getDeclaredConstructor()方法，拿到指定的构造器，再用构造器的newInstance()方法
    @Test
    public void test2() throws Exception{
        Class clazz = Animal.class;//拿到Class实例（即运行时类）
        Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);//这里和上面说的一致，对象都有Class实例，包括基本数据类型、字符串等等
        cons.setAccessible(true);
        Animal a = (Animal)cons.newInstance("Tom",10);
        System.out.println(a);
    }

Method m = stuClass.getMethod("show1", String.class);//拿到运行时类Method的实例对象
System.out.println(m);
//实例化一个Student对象
Object obj = stuClass.getConstructor().newInstance();
Object result = m.invoke(obj, 20);//需要两个参数，一个是要调用的对象（反射得到），一个是实参（m方法需要的参数）

public class Student {
    public static void show(){
        System.out.println("is show()");
    }
}

className = Student
methodName = show

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;

/*
 * 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改
 * 我们只需要将新类发送给客户端，并修改配置文件即可
 */
public class Demo {
    public static void main(String[] args) throws Exception {
        // 通过反射获取Class对象
        Class stuClass = Class.forName(getValue("className"));// "Student"
        // 2获取show()方法
        Method m = stuClass.getMethod(getValue("methodName"));// show
        // 3.调用show()方法
        m.invoke(stuClass.getConstructor().newInstance());
    }
    // 此方法接收一个key，在配置文件中获取相应的value
    public static String getValue(String key) throws IOException {
        Properties pro = new Properties();// 获取配置文件的对象
        FileReader in = new FileReader("pro.txt");// 获取输入流
        pro.load(in);// 将流加载到配置文件对象中
        in.close();
        return pro.getProperty(key);// 返回根据key获取的value值
    }
}

package fanXing;

import java.lang.reflect.Method;
import java.util.ArrayList;

/*
 * 通过反射越过泛型检查
 * 
 * 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
 */
public class FanXing {
    public static void main(String[] args) throws Exception {
        ArrayList<String> strList = new ArrayList<>();
        strList.add("aaa");
        strList.add("bbb");

        // strList.add(100);//如果直接在这添加 100 的话 编译就报错了。
        // 获取ArrayList的Class对象，反向的调用add()方法，添加数据 
        Class listClass = strList.getClass(); // 得到 strList 对象的字节码 对象
        // 获取add()方法
        Method m = listClass.getMethod("add", Object.class);
        // 调用add()方法
        m.invoke(strList, 100);

        // 遍历集合
        for (Object obj : strList) {
            System.out.println(obj);
        }
    }
}