一些关于Object和Class的测试，应用于方法参数

import java.lang.reflect.Field;
impor

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;

public class entrance {
    public static void main(String[] args) {
        //测试 Class_Data 得到的 Class 实例化对象的唯一性
        try {
//            Class_Data a = new Class_Data("1", "小学", "二年级", "二班", "true");
//
//            Class_Data b = new Class_Data("2", "初中", "二年级", "二班", "true");


            Class_Data a = new Class_Data();
            Class_Data b = new Class_Data("2", "初中", "二年级", "二班", "true");

            Class Class_Data_make_by_Class_1 = Class.forName("Class_Data");
            Class Class_Data_make_by_Class_2 = a.getClass();
            Class Class_Data_make_by_Class_3 = b.getClass();
            //测试两个实例得到的 Class 对象是否一样
            System.out.println("来源 a 的 Class:" + Class_Data_make_by_Class_1.hashCode());
            System.out.println("来源 a 但方法不同的 Class:" + Class_Data_make_by_Class_2.hashCode());
            System.out.println("来源 b 的 Class:" + Class_Data_make_by_Class_3.hashCode());
            //从 Hashcode 反应相等，应该是相同的，不过也有特例
            //--结果
            //--来源 a 的 Class:284720968
            //--来源 a 但方法不同的 Class:284720968
            //--来源 b 的 Class:284720968


            //通过 Class 反造 Class_Data_Table 的父类 Object。
            Object a_temp = Class_Data_make_by_Class_1.getConstructor().newInstance();
            Object b_temp = Class_Data_make_by_Class_2.getConstructor().newInstance();
            Field[] fieldArray_1 = a_temp.getClass().getFields();
            System.out.println("未经下溯，但由反射构造的 Class_Data 类" + new ArrayList(List.of(fieldArray_1)));

            Field[] fieldArray_2 = a.getClass().getFields();
            System.out.println("来自 a 的原始 Class_Data 类" + new ArrayList(List.of(fieldArray_2)));
            //--结果
            //--未经下溯，但由反射构造的 Class_Data 类 [public java.lang.String Class_Data.ID, public java.lang.String Class_Data.gLevel, public java.lang.String Class_Data.Grade, public java.lang.String Class_Data.Class, public java.lang.String Class_Data.Tag]
            //--来自 a 的原始 Class_Data 类 [public java.lang.String Class_Data.ID, public java.lang.String Class_Data.gLevel, public java.lang.String Class_Data.Grade, public java.lang.String Class_Data.Class, public java.lang.String Class_Data.Tag]
            //--上溯后的 Object 对象指向的 Class 对象还是最初的生成的 Class 对象


            //尝试通过访问 a_temp 未经下溯的字段值
            Field f = fieldArray_1[0];
            Class_Data a_temp_down = (Class_Data) a_temp;
            Class_Data b_temp_down = (Class_Data) b_temp;
            System.out.println("来源于 a 的反射：" + f.get(a_temp));
            System.out.println("来源于 a 的反射的下溯：" + f.get(a_temp_down));
            System.out.println("来源于 b 的反射：" + f.get(b_temp));

            //--结果
            //--但想要通过 Object 显式调用其成员依然需要下溯
            //--来源于 a 的反射：sadasd
            //--来源于 a 的反射的下溯：sadasd
            //--来源于 b 的反射：sadasd
            //结论，通过反射构造的 Object 的对象可以通过 Field 访问其未下溯的字段值，其字段值与调用的构造函数有关，

            //测试两个类实例上溯后生成的 Obejct 的 Class 对象是否一样，并且是否与原来的 Class 一样，同时还测试成员访问性和值的问题
            //即验证字段值和 Class 是否还是原来的
            Object a_father = a;
            Object b_father = b;
            System.out.println("来源 a 的 Class:" + Class_Data_make_by_Class_1.hashCode());
            System.out.println("来自 a 上溯的 Object a_father" + a_father.getClass().hashCode());
            System.out.println("来自 b 上溯的 Object b_father" + b_father.getClass().hashCode());
            //上溯后 Object 的 Class 依然指向最初的 Class
            f = fieldArray_1[0];
            System.out.println("查看 ar 的 ID" + f.get(a));
            System.out.println("查看 a_father 的 ID" + f.get(a_father));
            //--结果
            //--来源 a 的 Class:284720968
            //--来自 a 上溯的 Object a_father284720968
            //--来自 b 上溯的 Object b_father284720968
            //--查看 ar 的 IDsadasd
            //--查看 a_father 的 IDsadasd


            //大结论，Class 对象始终只有一份，对象上溯后，字段值不变，可以通过 Field 访问，其 Class 依然指向最初对象的类生成的 Class 对象
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}