反射机制的常见作用
Java反射初探：一个简单的例子
代码
package cn.hanquan.server;
/*
* 反射
* 1.获取Class对象
* 2.动态创建对象
*/
public class ReflectTest {
public static void main(String[] args) throws Exception {
// 1. 三种方式获取对象信息
// (1)对象.getclass
Class clz = new Iphone().getClass();
// (2)类.class
clz = Iphone.class;
// (3)Class.forName("包名.类名")
clz = Class.forName("cn.hanquan.server.Iphone");// 推荐这种方式
// 2. 创建对象
Iphone iphone2 = (Iphone) clz.getConstructor().newInstance();
System.out.println(iphone2);
}
}
class Iphone {
// 构造器
public Iphone() {
}
}
运行结果
cn.hanquan.server.Iphone@2c13da15
下面开始讲解反射
什么叫动态
动态：在运行时，可以改变程序的结构 。
Java不是动态语言，但是具有很多动态执行的特性，让Java的编程更加灵活。
上图中，可将字符串中的“ 包名 + 类名 ”在运行的时候，实时动态加载到程序中。
好处是：只要传入不同的类（字符串的内容是可以根据逻辑判断改变的），就可以加载不同的类。
Class类介绍
官方API的解释如下图：
就是说，所有的类型都是一个Class对象
-
一个类被加载后，JVM会创建一个对应类该类的Class对象，类的整个结构信息会放到对应的Class对象中
-
这个Class对象就像一面镜子，通过这面镜子，可以看到对应类的全部信息——这就是反射机制
-
注意： 一个类只会有一个对象，第二次加载同一个类与第一次得到的结果相同 (把Class想象成图纸，通过一张图纸可以创造很多汽车，但是，图纸只有一张)
示例代码1：获取Class对象
Demo1.java
package cn.hanquan.reflect;
/*
* 测试各种类型java.lang.Class对象的获取方式
*/
public class Demo1 {
public static void main(String[] args) {
String path = "cn.hanquan.reflect.User";
try {
// 获取Class对象:方法一
Class<?> c1 = Class.forName(path);// 第一次加载类
/*
* 一个类被加载后，JVM会创建一个对应类该类的Class对象，类的整个结构信息会放到对应的Class对象中
* 这个Class对象就像一面镜子，通过这面镜子，可以看到对应类的全部信息——这就是反射机制
*
* 注意： 一个类只会有一个对象，第二次加载同一个类与第一次得到的结果相同。同样维数的数组，第二次加载结果也相同，和维度有关，和长度无关。
* (把Class想象成图纸，通过一张图纸可以创造很多汽车，但是图纸只有一张)
*/
System.out.println("User -> " + c1);
System.out.println("User -> " + c1.hashCode());
Class<?> c2 = Class.forName(path);// 第二次加载类
System.out.println("User -> " + c2);
System.out.println("User -> " + c2.hashCode());
// 获取Class对象:方法二
Class strClass1 = String.class;// (例：获取String的Class)
Class strClass2 = path.getClass();// 获取的是同一个对象
System.out.println("String -> " + strClass1);
System.out.println("String -> " + strClass2);
Class intClass = int.class;// (例：获取基本数据类型的Class)
System.out.println("int -> " + intClass.getClass().hashCode());
int[] arr1 = new int[10];// (例：获取数组基本数据类型的Class)
int[] arr2 = new int[30];// 是同一个对象
int[][] arr3 = new int[10][10];// 不是同一个对象
System.out.println("array[] -> " + arr1.getClass().hashCode());
System.out.println("array[] -> " + arr2.getClass().hashCode());
System.out.println("array[][] -> " + arr3.getClass().hashCode());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
（JavaBean）User.java
package cn.hanquan.reflect;
public class User {
int id;
int age;
String uname;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return uname;
}
public void setName(String uname) {
this.uname = uname;
}
public User(int id, int age, String uname) {
super();
this.id = id;
this.age = age;
this.uname = uname;
}
public User() {
}
}
运行结果
User -> class cn.hanquan.reflect.User
User -> 1361960727
User -> class cn.hanquan.reflect.User
User -> 1361960727
String -> class java.lang.String
String -> class java.lang.String
int -> 705927765
array[] -> 739498517
array[] -> 739498517
array[][] -> 125130493
示例代码2：利用反射，获取类的信息
User.java与示例代码1中相同，此处不再重复粘贴
Demo2.java
package cn.hanquan.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*
* 应用反射的API，获取类的信息（类的名字、属性、方法、构造器等）
*/
public class Demo2 {
public static void main(String[] args) {
String path = "cn.hanquan.reflect.User";
try {
// 获取Class对象
Class<?> uClass = Class.forName(path);
// 获取类的名字
System.out.println("getName -> " + uClass.getName());// 全路径：包名+类名
System.out.println("getSimpleName -> " + uClass.getSimpleName());// 类型
// 获取属性信息
System.out.println("\n-----------获取属性信息-----------");
Field[] fields1 = uClass.getFields();// 只获取public的Field
System.out.println("getFields -> " + fields1.length);
Field field = uClass.getDeclaredField("uname");// 获取指定Field
System.out.println("getDeclaredField(String)-> " + field);
Field[] fields2 = uClass.getDeclaredFields();// 获取所有Field
System.out.println("getDeclaredFields -> " + fields2.length);
for (Field f : fields2) {
System.out.println("Field[] -> " + f.toString());
}
// 获取方法信息
System.out.println("\n-----------获取方法信息-----------");
Method[] methods = uClass.getDeclaredMethods();// 获取所有方法
for (Method m : methods) {
System.out.println("Method[] -> " + m.toString());
}
Method method1 = uClass.getDeclaredMethod("getUname", null);// 获取指定方法
System.out.println("getDeclaredMethod -> " + method1.toString());
Method method2 = uClass.getDeclaredMethod("setUname", String.class);// 传递参数类型对应的class对象 否则无法区分重载方法
System.out.println("getDeclaredMethod -> " + method2.toString());
// 获取构造器信息
System.out.println("\n-----------获取构造器信息-----------");
Constructor<?>[] cons = uClass.getDeclaredConstructors();// 获取所有构造器
for (Constructor con : cons) {
System.out.println("Constructor[] -> " + con.toString());
}
Constructor<?> con1 = uClass.getDeclaredConstructor(null);// 获取指定构造器
System.out.println("getDeclaredConstructor -> " + con1.toString());
Constructor<?> con2 = uClass.getDeclaredConstructor(int.class, int.class, String.class);// 获取指定构造器
System.out.println("getDeclaredConstructor -> " + con2.toString());
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果
getName -> cn.hanquan.reflect.User
getSimpleName -> User
-----------获取属性信息-----------
getFields -> 0
getDeclaredField(String)-> private java.lang.String cn.hanquan.reflect.User.uname
getDeclaredFields -> 3
Field[] -> private int cn.hanquan.reflect.User.id
Field[] -> private int cn.hanquan.reflect.User.age
Field[] -> private java.lang.String cn.hanquan.reflect.User.uname
-----------获取方法信息-----------
Method[] -> public int cn.hanquan.reflect.User.getId()
Method[] -> public java.lang.String cn.hanquan.reflect.User.getUname()
Method[] -> public void cn.hanquan.reflect.User.setUname(java.lang.String)
Method[] -> public void cn.hanquan.reflect.User.setAge(int)
Method[] -> public void cn.hanquan.reflect.User.setId(int)
Method[] -> public int cn.hanquan.reflect.User.getAge()
getDeclaredMethod -> public java.lang.String cn.hanquan.reflect.User.getUname()
getDeclaredMethod -> public void cn.hanquan.reflect.User.setUname(java.lang.String)
-----------获取构造器信息-----------
Constructor[] -> public cn.hanquan.reflect.User()
Constructor[] -> public cn.hanquan.reflect.User(int,int,java.lang.String)
getDeclaredConstructor -> public cn.hanquan.reflect.User()
getDeclaredConstructor -> public cn.hanquan.reflect.User(int,int,java.lang.String)
示例代码3：通过反射，动态操作：构造器、方法、属性
User.java与示例代码1中相同，此处不再重复粘贴
Demo3.java
package cn.hanquan.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/*
* 通过反射API, 动态操作：构造器、方法、属性
*/
@SuppressWarnings(value = { "all" })
public class Demo3 {
public static void main(String[] args) {
try {
String path = "cn.hanquan.reflect.User";
Class<User> uClass = (Class<User>) Class.forName(path);
// 通过反射API调用构造方法
User u1 = uClass.newInstance();// 实质上调用了User的无参构造方法
Constructor<?> con1 = uClass.getDeclaredConstructor(int.class, int.class, String.class);// 获取指定构造器
User u2 = (User) con1.newInstance(1001, 18, "逆风敲代码的程序猿");// 创建对象
System.out.println("调用构造 -> " + u2.getUname());
// 通过反射API调用普通方法
User u3 = uClass.newInstance();
Method m = uClass.getDeclaredMethod("setUname", String.class);// 好处是：方法名称是变量 可以从别的地方动态的传过来
m.invoke(u3, "码农");// 激活方法 动态调用
System.out.println("调用方法 -> " + u3.getUname());
// 通过反射API操作属性
User u4 = uClass.newInstance();
Field f = uClass.getDeclaredField("uname");
f.setAccessible(true);// 不用做私有属性安全检查 直接可以访问
f.set(u4, "魔鬼鱼");// 通过反射直接写属性
System.out.println("操作属性 -> " + u4.getUname());// 直接调用
System.out.println("获得属性 -> " + f.get(u4));// 通过反射调用
} catch (Exception e) {
e.printStackTrace();
}
}
}
运行结果
调用构造 -> 逆风敲代码的程序猿
调用方法 -> 码农
操作属性 -> 魔鬼鱼
获得属性 -> 魔鬼鱼
扫一扫
6401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
