操作反射中构造方法、属性和普通方法
文章目录
一、构造方法
二、属性
三、普通方法
Student类中代码：
一、构造方法
public class Student {
public String name;
public String address;
public Student() {
}
private Student(String name) {
this.name = name;
}
public Student(String name,String address) {
this.name = name;
this.address = address;
}
public void doHomework(){
System.out.println(name+"正在做作业");
}
}
获取构造方法
public class Test {
public static void main(String[] args) {
//获取构造方法步骤
//step1:获取Student类的Class对象
Class clazz = Student.class;
//step2:获得构造方法，首先分为是否区分访问权限，其次通过参数列表的不同，调用不同的构造方法
//1、区分访问权限通过参数列表的不同，得到不同的构造方法,，以下代码获得public级别的构造方法
try {
Constructor<Student> constructor = clazz.getConstructor();//得到public级别的无参构造方法
System.out.println(constructor.getName());
constructor = clazz.getConstructor(String.class,String.class);//得到参数列表中有俩个参数且都为String类型的public级别构造方法
System.out.println(constructor.getName());
} catch (Exception e) {
e.printStackTrace();
}
//2、不区分访问权限，通过参数列表的不同，得到不同的构造方法
try {
Constructor<Student> constructor = clazz.getDeclaredConstructor();//得到public级别的无参构造方法
System.out.println(constructor.getName());
constructor = clazz.getDeclaredConstructor(String.class);//得到参数列表中只有一个参数且为String类型的被private修饰的构造方法
System.out.println(constructor.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}输出结果
获得构造方法的信息
public class Test {
public static void main(String[] args) {
//获取构造方法信息步骤
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//step2:获得构造方法，首先分为是否区分访问权限，其次通过参数列表的不同，调用不同的构造方法
Constructor <Student> constructor = clazz.getConstructor();//得到public级别的无参构造方法
//调用Constructor中的对应方法，得到相对应的信息
//a、得到构造方法对应的类的Class对象
Class zz = constructor.getDeclaringClass();
System.out.println("构造方法对应的类的Class对象"+":"+zz.getName());
//b、得到构造方法的修饰符
int mod = constructor.getModifiers();
String modName = Modifier.toString(mod);
System.out.println("构造方法的修饰符"+":"+modName);
//c、得到构造方法的参数对应的Class对象组成的数组
Class<?>[] paramTypes = constructor.getParameterTypes();
for (Class<?> paramType: paramTypes) {
System.out.println("构造方法的参数对应的Class对象"+":"+paramType);//此时由于调用的是无参构造方法，没有参数,数组长度为零，因此没有输出
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
输出结果
使用构造方法
public class Test {
public static void main(String[] args) {
//使用构造方法步骤
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//step2:获得构造方法，首先分为是否区分访问权限，其次通过参数列表的不同，调用不同的构造方法
Constructor <Student> constructor = clazz.getDeclaredConstructor(String.class);//得到private级别的有参构造方法
//step3:通过构造方法创建声明它的类的对象，如果该构造方法被private修饰，可以调用setAccessible(boolean)方法，来改变权限
//将权限设为public级别
constructor.setAccessible(true);
//创建对象
Object obj = constructor.newInstance("Tom");
Student stu = (Student)obj;
//调用方法
stu.doHomework();
} catch (Exception e) {
e.printStackTrace();
}
}
}二、属性
Student中代码
public class Student extends Person {
private int age;
public String name;
public String address ="河南";
}Person中代码
public class Person {
private String id;
public String mobile;
}
获取成员变量
public class Test {
public static void main(String[] args) {
//获得成员变量对应的Field对象
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//step2:获得成员变量对应的Field对象，首先分为是否区分访问权限以及是否需要继承、获得全部成员变量还是单个成员变量调用不同的方法
System.out.println("区分访问权限，包含继承过来的成员变量***************************************************************");
System.out.println("获得全部的public级别的成员变量~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
//获得全部public级别的成员变量对应的Field对象，包含继承过来的public级别的成员变量
Field [] fields = clazz.getFields();
for (Field field : fields) {
System.out.println(field.getName());
}
System.out.println("获得指定的public级别成员变量~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
//获得指定的public级别的成员变量对应的Field对象，包含继承过来的public级别的成员变量
Field field = clazz.getField("mobile");//此时的mobile是Student的父类Person中的成员变量
System.out.println(field.getName());
System.out.println("不区分访问权限，不包含包含继承过来的成员变量***************************************************************");
System.out.println("获得全部的成员变量，不包含包含继承过来的成员变量#########################################");
//获得全部成员变量，不包含继承过来的成员变量
fields = clazz.getDeclaredFields();
for (Field field2 : fields) {
System.out.println(field2.getName());
}
System.out.println("获得指定的成员变量，不包含包含继承过来的成员变量#######################################");
//获得指定成员变量对应的Field对象，不包含继承过来的成员变量
Field field2 = clazz.getDeclaredField("age");//此时的age是被private修饰的成员变量
System.out.println(field.getName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果
得到成员变量的信息
public class Test {
public static void main(String[] args) {
//获得成员变量信息
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//step2:获得成员变量
//获得指定的public级别的成员变量对应的Field属性，包含继承过来的public级别的成员变量
Field field = clazz.getField("mobile");//此时的mobile是Student的父类Person中的成员变量
//返回声明Field对象表示字段的类或接口所对应的Class对象
Class zz = field.getDeclaringClass();
System.out.println(zz.getName());
//获得成员变量的修饰符
int mod = field.getModifiers();
String modName = Modifier.toString(mod);
System.out.println(modName);
//获得成员变量的数据类型的Class对象
Class dataType = field.getType();
System.out.println(dataType);
//返回此Field对象所表示字段的声明类型
Object obj = field.getGenericType();
System.out.println(obj);
//得到成员变量的名称
String name = field.getName();
System.out.println(name);
} catch (Exception e) {
e.printStackTrace();
}
}
}输出结果
使用成员变量
public class Test {
public static void main(String[] args) {
//操作成员变量
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//step2:创建学生对象
Constructor constructor = clazz.getConstructor();
Object obj = constructor.newInstance();
Student stu = (Student)obj;
//获得成员变量address对应的Field对象
Field field = clazz.getField("address");
//得到成员变量的值
Object address = field.get(stu);
System.out.println(address);
//设置成员变量的值
field.set(stu,"上海");
address = field.get(stu);
System.out.println(address);
field =clazz.getDeclaredField("age");
//修改成员变量权限
field.setAccessible(true);
field.set(stu,11);
Object age = field.get(stu);
System.out.println(age);
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果
三、普通方法
Student中代码
public class Student extends Person {
public void doHomeWork() {
System.out.println("正在做作业");
}
public void doHomeWork(String name) {
System.out.println(name+"正在做作业");
}
private void eat() {
System.out.println("正在吃饭");
}
}
Person中的代码
public class Person {
public void shopping() {
System.out.println("正在购物");
}
private void swimming() {
System.out.println("正在游泳");
}
}
获取普通的方法
public class Test {
public static void main(String[] args) {
//得到普通方法
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//得到Student类中所有的public级别的普通方法，包含继承public级别的
Method[] methods = clazz.getMethods();
for (Method method : methods) {
System.out.println(method.getName()+"这是指定的普通方法,含继承");
}
//得到Student类中指定的名称，与参数类型相匹配的public级别的普通方法，包含继承过来的方法,所以也会有Object类中的public级别的方法
Method methode2 = clazz.getMethod("doHomeWork",String.class);
System.out.println(methode2.getName()+"这是指定的普通方法,含继承");
System.out.println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
//得到Student类中所有的普通方法，不包含继承的
methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println(method.getName()+"这是指定的普通方法,不包含继承");
}
//得到Student类中指定的名称，与参数类型相匹配的的普通方法，不包含继承过来的方法
methode2 = clazz.getDeclaredMethod("doHomeWork",String.class);
System.out.println(methode2.getName()+"这是指定的普通方法,不包含继承");
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果
得到普通方法的信息
public class Test {
public static void main(String[] args) {
//得到普通方法的信息
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//得到Student类中指定的名称，与参数类型相匹配的的普通方法，不包含继承过来的方法
Method methode = clazz.getDeclaredMethod("doHomeWork",String.class);
System.out.println(methode.getName()+"这是指定的普通方法,不包含继承");
//得打到修饰符
System.out.println(Modifier.toString(methode.getModifiers()));
//得到返回值类型
Class zz = methode.getReturnType();
System.out.println(zz.getName());
//得到方法的参数列表
Class [] clazzs = methode.getParameterTypes();
for (Class cla : clazzs) {
System.out.println(cla.getName());
}
} catch (Exception e) {
e.printStackTrace();
}
}
}运行结果
操作普通方法
public class Test {
public static void main(String[] args) {
//操作普通方法
//step1:获取Student类的Class对象
Class clazz = Student.class;
try {
//得到Student类中指定的名称，与参数类型相匹配的的普通方法，不包含继承过来的方法
Method methode = clazz.getDeclaredMethod("doHomeWork",String.class);
//调用普通方法，在反射中方法的调用不区分静态和非静态
Object obj = methode.invoke(new Student(),"Tom");
System.out.println(obj);//返回值为null
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果
