java 根据class获取对象_java基础—反射（根据Class获取对象信息Object.class）

Java的反射(reflection)机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

//User类，子类

User user = new User();

//Parent类，User的父类

Parent parent = new Parent();

//获取类的类型Class的三种方式

Class z = User.class;

Class c = new User().getClass();

//动态获取

Class l = Class.forName("com.zqq.test.User");

字段操作 Field

Class c = user.getClass();

//获取当前字段类所有,不包含父类字段，返回Field数组

c.getDeclaredFields();

//获取当前类所有public修饰的字段,含父类public修饰的字段，返回Field数组

c.getFields();

//根据名称获取当前类字段 不包括父类，返回Field对象

c.getDeclaredField("age");

//根据字段名称获取public修饰的字段，包括父类字段，返回Field对象

c.getField("pubName");

//是否可以通过放射访问该字段 可以 true 不可以 false

Field.isAccessible();

//设置成可以通过反射访问该字段

Field.setAccessible(true);

Demo

User user = new User();

user.setName("xiaoxiao");

user.setAge(18);

User user1 = new User();

System.out.println(user == user1);

System.out.println(user.getClass() == user1.getClass());

Class c = user.getClass();

//getDeclaredFields 获取当前字段类所有,不包含父类字段

for(Field f : c.getDeclaredFields()){

System.out.println(f.getName());

}

// c.getFields() 获取当前类所有public修饰的字段,含父类public修饰的字段

for(Field f : c.getFields()){

System.out.println(f.getName());

}

// c.getDeclaredField 根据名称获取当前类字段 不包括父类

Field field = c.getDeclaredField("age");

System.out.println("字段信息====：" + field.toString());

//c.getField(name) 根据字段名称获取public修饰的字段，包括父类字段

//System.out.println("本身私有字段====age：" + c.getField("age")); // 报错 java.lang.NoSuchFieldException

System.out.println("本身public字段pubAge======pubAge：" + c.getField("pubAge"));

System.out.println("父类public修饰字段===========pubName :" + c.getField("pubName"));

//获取字段的值

Field nameField = c.getDeclaredField("name");

System.out.println("是否可以通过反射访问该字段：" + nameField.isAccessible());

// isAccessible为false时不可以通过反射访问该字段，设置成true

nameField.setAccessible(true);

System.out.println("是否可以通过反射访问该字段：" + nameField.isAccessible());

Object name = nameField.get(user);

System.out.println("获取到字段的值为：" + name);

//设置字段的值

nameField.set(user,"大小小");

System.out.println(user.getName());

方法操作 Method

Class c = User.class;

//获取public修饰的方法(包括父类)，传入方法名称

c.getMethod("say");

//获取所有public修饰的方法(包括父类)

c.getMethods();

//获取当前类的方法(所有作用域)(不包括父类),传入方法名称

c.getDeclaredMethod("getName");

//获取当前类所有方法(不包括父类)

c.getDeclaredMethods();

//返回方法返回值类型

Method.getReturnType();

//返回方法参数类型

Method.getParameterTypes();

//返回方法的修饰符，public、private ...

Modifier.toString(Method.getModifiers());

//通过反射调用方法,传入对象的实例，静态方法实例传null

Method.invoke(new User(),'参数，没有不填');

//设置可以通过反射访问该方法

method.setAccessible(true);

Demo

Class c = User.class;

//获取public的方法(包括父类)

Method method = c.getMethod("say");

//获取所有public的方法包括父类

Method[] methods = c.getMethods();

//获取当前类的方法(所有作用域)(不包括父类)

method = c.getDeclaredMethod("getName");

//获取当前类所有方法(不包括父类)

methods = c.getDeclaredMethods();

System.out.println(method.toString());

System.out.println("方法名称：" + method.getName());

System.out.println("方法返回值类型：" + method.getReturnType());

System.out.println("方法的参数类型：" + method.getParameterTypes());

System.out.println("方法的修饰符：" + Modifier.toString(method.getModifiers()));

//调用方法

method = c.getMethod("say");

//传入对象的实例

method.invoke(new User());

//调用静态方法，实例传null

Method statciMethon = c.getMethod("sayStatic");

statciMethon.invoke(null);

//调用private修饰的方法，需要设置 Method.setAccessible(true)，否则会报错 java.lang.NoSuchMethodException

method = c.getDeclaredMethod("sayPrivate");

method.setAccessible(true);

method.invoke(new User());

构造方法

//创建对象 , newInstance只能调用public修饰的无参构造方法，有参或者不是public修饰则创建不了对象

User user = User.class.newInstance();

user.setName("zqq");

System.out.println(user.toString());

//Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例,可以调用任意构造方法

Constructor constructor = User.class.getDeclaredConstructor(String.class);

User u = (User) constructor.newInstance("zqqqqq");

System.out.println(u.toString());

继承关系 ps:看框架源码的时候可以先获取对象的继承关系

Class c = User.class;

//获取父类的Class，返回对象，java单继承

c.getSuperclass();

//获取实现的接口，返回数组，java多实现

c.getInterfaces();

//isAssignableFrom() 判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。如果是则返回 true

Parent.Class.isAssignableFrom(c);

Demo

//获取类类型的方式， 类类型 就是类的类型

Class z = User.class;

Class c = new User().getClass();

//传入类的完整类名

Class l = Class.forName("com.zqq.test.User");

//这三种方式获取的Class都是同一个Class，因为JVM对每个加载的Class只创建一个Class实例来表示它的类型

System.out.println(z == c && c == l);

//获取父类的Class ,阅读源码的时候可以无限往上看看都继承了哪个父类，继承的接口也一样

Class p = l.getSuperclass();

System.out.println("父类class：" + p);

//获取实现的接口

Class[] interfaces = l.getInterfaces();

for(Class inter : interfaces){

System.out.println(inter.toString());

}

// instanceof 判断某个实例是否是某个类型

System.out.println(new User() instanceof com.zqq.test.User);

// isAssignableFrom() 判定此 Class 对象所表示的类或接口与指定的 Class 参数所表示的类或接口是否相同，或是否是其超类或超接口。如果是则返回 true

System.out.println(User.class.isAssignableFrom(Parent.class));

System.out.println(Parent.class.isAssignableFrom(User.class));

【往期精彩视频】