java 反射
作者：互联网
类对象
类对象：类加载的产物，封装了一个类的所有信息（类名，父类，接口，属性，方法，构造方法）
每一个类加载到内存之后都对应一个class对象
每个类有且只有一个class对象
获取类对象
-
通过类的对象获取类对象
-
Student s = new Student();
-
Class<?> c = s.getClass();
-
-
通过类名获取类对象
-
Class<?> c = 类名.class;
-
-
通过静态方法获取类对象（记得抛出异常）[推荐使用]
-
Class<?> c = Class.forName("包名.类名");
-
反射
常用方法
-
public String getName()
-
public Package getPackage()
-
public Class<? super T> getSuperclass()
-
public Class<?>[] getInterfaces()
-
public Constructor<?>[] getConstructor()
-
public T newInstance()
-
public Method[] getMethods()
-
public Field[] getFields()
常见操作
附：person类
public class person implements Serializable,Cloneable {
public String name;
public person() {
}
public person(String name) {
this.name = name;
}
public void eat(){
System.out.println(this.name+"在吃饭");
}
@Override
public String toString() {
return "person{" +
"name='" + name + '\'' +
'}';
}
public void eat(String food){
System.out.println(this.name+"在吃"+food);
}
private void sleep(){
System.out.println(this.name + "在睡觉");
}
public static void quiet(){
System.out.println("保持安静");
}
}
使用反射获取类的名字，包名，父类，接口
public class Demo1 {
public static void main(String[] args) throws Exception{
reflectOpe1();
}
public static void reflectOpe1() throws Exception{
//1 获取类对象person
Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
//获得类的全名称
System.out.println(class1.getName());
//得到包名(getPackage() 返回包的类对象)
System.out.println(class1.getPackage().getName());
//获取父类()(getSuperclass() 返回父类的类对象)
System.out.println(class1.getSuperclass().getName());
//获取接口(getInterfaces() 返回数组)
Class<?>[] classes = class1.getInterfaces();
System.out.println(Arrays.toString(classes));
}
}
使用反射获取类的构造方法并创建对象
public class Demo1 {
public static void main(String[] args) throws Exception{
reflectOpe2();
}
public static void reflectOpe2() throws Exception{
Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
//获取类的构造方法Constructor(getConstructors()返回数组)
Constructor<?>[] cons = class1.getConstructors();
for (Constructor<?> con : cons){
System.out.println(con.toString());
}
//获取类中的无参构造
Constructor<?> con = class1.getConstructor();
Object zhangsan = (person)con.newInstance();
System.out.println(zhangsan.toString());
//简便方法
person wangwu = (person) class1.newInstance();
System.out.println(wangwu.toString());
//获取类中的带参构造
Constructor<?> con2 = class1.getConstructor(String.class);
person xiaoli = (person) con2.newInstance("小李");
System.out.println(xiaoli.toString());
}
}
使用反射获取类中的方法并调用
public class Demo1 {
public static void main(String[] args) throws Exception{
reflectOpe3();
}
public static void reflectOpe3() throws Exception{
Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
//获取方法
//getMethods() 获取公开的方法 包括继承的方法
Method[] methods = class1.getMethods();
for (Method method : methods) {
System.out.println(method.toString());
}
//getDeclaredMethods() 获取所有方法，不包含继承的
Method[] Methods2 = class1.getDeclaredMethods();
for (Method method : Methods2) {
System.out.println(method.toString());
}
//获取单个方法
//调用无参无返回值
Method eatMethod = class1.getMethod("eat");
person zhangsan = (person) class1.newInstance();
eatMethod.invoke(zhangsan);
//无参有返回值
Method toStringMethod = class1.getMethod("toString");
Object result = toStringMethod.invoke(zhangsan);
System.out.println(result);
//带参
Method eatMethod2 = class1.getMethod("eat",String.class);
eatMethod2.invoke(zhangsan,"鸡腿");
//获取私有方法
Method privateMethod = class1.getDeclaredMethod("sleep");
//设置访问权限无效
privateMethod.setAccessible(true);
privateMethod.invoke(zhangsan);
//获取静态方法
Method staticMethod = class1.getMethod("quiet");
staticMethod.invoke(null);
}
}
反射调用任何对象的通用方法
public class Demo1 {
public static void main(String[] args) throws Exception{
Properties properties = new Properties();
//原本的方法
properties.setProperty("name","zhangsan");
System.out.println(properties.toString());
//invokeAny()
invokeAny(properties,"setProperty",new Class[]{String.class,String.class},"username","张三");
System.out.println(properties.toString());
}
public static Object invokeAny(Object obj,String methodName,Class<?>[] types,Object...args) throws Exception{
//obj是对象名，methodName是方法名，types是方法参数，args是参数的数据
//获取类对象
Class<?> class1 = obj.getClass();
//获取方法
Method method = class1.getMethod(methodName,types);
//调用
return method.invoke(obj,args);
}
}
使用反射获取类中的属性
public class Demo1 {
public static void main(String[] args) throws Exception{
reflectope4();
}
public static void reflectope4() throws Exception{
//获取类对象
Class<?> class1 = Class.forName("cn.zlt.qq.client.test.person");
//获取属性(字段) 公开的字段，父类继承的字段
Field[] fields = class1.getFields();
System.out.println(fields.length);
//获取属性(字段) 所有字段 不包含继承
Field[] fields1 = class1.getDeclaredFields();
System.out.println(fields1.length);
//获取name属性
Field namefield = class1.getDeclaredField("name");
namefield.setAccessible(true);//设置权限
//赋值 正常调用
person zhangsan = (person) class1.newInstance();
namefield.set(zhangsan,"张三");//相当于zhangsan.name = "张三";
//获取值
System.out.println(namefield.get(zhangsan));
}
}
标签：反射,java,System,person,println,out,public,class1 来源： https://www.cnblogs.com/SummeRr/p/15615406.html