本文主要是介绍【Java反射】Java动态性——反射机制，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
反射机制的常见作用
Java反射初探：一个简单的例子
代码
package cn.hanquan.server;/** 反射* 1.获取Class对象* 2.动态创建对象*/
public class ReflectTest {public static void main(String[] args) throws Exception {// 1. 三种方式获取对象信息// (1)对象.getclassClass clz = new Iphone().getClass();// (2)类.classclz = 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的FieldSystem.out.println("getFields -> " + fields1.length);Field field = uClass.getDeclaredField("uname");// 获取指定FieldSystem.out.println("getDeclaredField(String)-> " + field);Field[] fields2 = uClass.getDeclaredFields();// 获取所有FieldSystem.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();}}
}运行结果
调用构造 -> 逆风敲代码的程序猿
调用方法 -> 码农
操作属性 -> 魔鬼鱼
获得属性 -> 魔鬼鱼
这篇关于【Java反射】Java动态性——反射机制的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
