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