-
反射机制的作用
通过java语言中的反射机制可以操作字节码文件。优点类似于黑客。（可以读和修改字节码文件。）通过反射机制可以操作代码片段。（class文件。）
-
反射机制的相关类在哪个包下？
java.lang.reflect.*; -
反射机制相关的重要的类
java.lang.Class：代表整个字节码，代表一个类型，代表整个类。
java.lang.reflect.Method：代表字节码中的方法字节码。代表类中的方法。 java.lang.reflect.Constructor：代表字节码中的构造方法字节码。代表类中的构造方法 java.lang.reflect.Field：代表字节码中的属性字节码。代表类中的成员变量（静态变量+实例变量）。 java.lang.Class： public class User{ // Field int no; // Constructor public User(){ } public User(int no){ this.no = no; } // Method public void setNo(int no){ this.no = no; } public int getNo(){ return no; } }
二、获取Class的三种方式
第一种：Class c = Class.forName(“完整类名带包名”);
①静态方法
②方法的参数是一个字符串。
③字符串需要的是一个完整类名。
④完整类名必须带有包名。java.lang包也不能省略。
第二种：Class c = 对象.getClass();
第三种：Class c = 任何类型.class;
package Reflect;
import java.util.Date;
public class ReflectTest01 {
public static void main(String[] args) {
Class c1 = null;
Class c2 = null;
//第一种方式
try {
c1 = Class.forName("java.lang.String");// c1代表String.class文件，或者说c1代表String类型。
c2 = Class.forName("java.util.Date");// c2代表Date类型
Class c3 = Class.forName("java.lang.Integer"); // c3代表Integer类型
Class c4 = Class.forName("java.lang.System"); // c4代表System类型
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
//第二种方式 java中任何一个对象都有一个方法：getClass()
String s = "abc";
Class x = s.getClass(); // x代表String.class字节码文件，x代表String类型。
System.out.println(c1 == x); // true（==判断的是对象的内存地址。）
Date time = new Date();
Class y = time.getClass();
System.out.println(c2 == y); // true (c2和y两个变量中保存的内存地址都是一样的，都指向方法区中的字节码文件。)
// 第三种方式，java语言中任何一种类型，包括基本数据类型，它都有.class属性。
Class z = String.class; // z代表String类型
Class k = Date.class; // k代表Date类型
Class f = int.class; // f代表int类型
Class e = double.class; // e代表double类型
System.out.println(x == z); // true
}
}
-
通过反射实例化对象
package Reflect2; public class ReflectTest02 { public static void main(String[] args) { try { Class c = Class.forName("Reflect2.User"); // newInstance() 这个方法会调用User这个类的无参数构造方法，完成对象的创建。必须保证无参构造是存在的！ Object obj = c.newInstance(); System.out.println(obj); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } } }package Reflect2; public class User { public User() { System.out.println("无参构造！"); } }（1）通过Class的newInstance()方法来实例化对象。
注意：newInstance()方法内部实际上调用了无参数构造方法，必须保证无参构造存在才可以。（2）这种实例化对象比较灵活
java代码写一遍，再不改变java源代码的基础之上，可以做到不同对象的实例化。
（符合OCP开闭原则：对扩展开放，对修改关闭。）
package Reflect2; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; import java.util.Properties; public class ReflectTest03 { public static void main(String[] args) throws Exception { // 通过IO流读取classinfo.properties文件 FileReader reader = new FileReader("Day4/src/file.properties"); // 创建属性类对象Map Properties pro = new Properties(); // key value都是String // 加载 pro.load(reader); // 关闭流 reader.close(); // 通过key获取value String className = pro.getProperty("className"); //System.out.println(className); // 通过反射机制实例化对象 Class c = Class.forName(className); Object obj = c.newInstance(); System.out.println(obj); } }如果file.properties配置文件中写的是：className=java.util.Date
这个程序运行结果为：Sat Jan 01 18:31:50 CST 2022
代码不需要改动，可以修改配置文件，配置文件修改之后，可以创建出不同的实例对象。
（3）只让静态代码块执行可以使用forName，这个方法的执行会导致类加载，类加载时，静态代码块执行。
package Reflect2; public class ReflectTest04 { public static void main(String[] args) { try { // Class.forName()这个方法的执行会导致：类加载。 Class.forName("Reflect2.MyClass"); } catch (ClassNotFoundException e) { e.printStackTrace(); } } } class MyClass{ static { System.out.println("静态代码块执行"); } } -
获取类路径下文件的绝对路径
前提：文件需要在类路径下
package Reflect; public class PathTest { public static void main(String[] args) { String path = Thread.currentThread().getContextClassLoader() .getResource("file.properties").getPath(); // 这种方式获取文件绝对路径是通用的。 System.out.println(path); } } -
以流的形式直接返回
package Reflect; import java.io.IOException; import java.io.InputStream; import java.util.Properties; public class IoPropertiesTest { public static void main(String[] args) throws IOException { // 直接以流的形式返回。 InputStream reader = Thread.currentThread().getContextClassLoader() .getResourceAsStream("file.properties"); Properties pro = new Properties(); pro.load(reader); reader.close(); // 通过key获取value String className = pro.getProperty("className"); System.out.println(className); } } -
资源绑定器
java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容。使用以下这种方式的时候，属性配置文件xxx.properties 必须放到类路径下。写的时候，后面的扩展名不能写。
package Reflect;import java.util.ResourceBundle;public class ResourceBundleTest { public static void main(String[] args) { ResourceBundle bundle = ResourceBundle.getBundle("file"); String className = bundle.getString("className"); System.out.println(className); }} -
类加载器
（1）什么是类加载器？
专门负责加载类的命令/工具。ClassLoader
（2）JDK中自带了3个类加载器：
启动类加载器:rt.jar
扩展类加载器:ext noFiled.set(obj, 22222); // 给obj对象的no属性赋值2222 // 读取属性的值 // 两个要素：获取obj对象的no属性的值。 System.out.println(noFiled.get(obj)); // 访问私有的属性 Field nameField = studentClass.getDeclaredField("name"); // 打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会！） // 这样设置完之后，在外部也是可以访问private的。 nameField.setAccessible(true); // 给name属性赋值 nameField.set(obj, "jackson"); // 获取name属性的值 System.out.println(nameField.get(obj)); }}
四、反射Method
-
可变长度参数
int… args 这就是可变长度参数
语法是：类型… （注意：一定是3个点。）（1）可变长度参数要求的参数个数是：0~N个。
（2）可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有1个。
（3）可变长度参数可以当做一个数组来看待package Reflect3;public class ArgsTest { public static void main(String[] args) { m(); m(10); m(10, 20); // 编译报错 //m("abc"); } public static void m(int... args){ System.out.println("m方法执行了！"); }} -
反射Method
package Reflect4;import java.lang.reflect.Method;import java.lang.reflect.Modifier;public class ReflectTest08 { public static void main(String[] args) throws Exception{ // 获取类 Class userServiceClass = Class.forName("Reflect4.UserService"); // 获取所有的Method（包括私有的！） Method[] methods = userServiceClass.getDeclaredMethods(); // 遍历Method for(Method method : methods){ // 获取修饰符列表 System.out.println(Modifier.toString(method.getModifiers())); // 获取方法的返回值类型 System.out.println(method.getReturnType().getSimpleName()); // 获取方法名 System.out.println(method.getName()); // 方法的修饰符列表（一个方法的参数可能会有多个。） Class[] parameterTypes = method.getParameterTypes(); for(Class parameterType : parameterTypes){ System.out.println(parameterType.getSimpleName()); } } }}package Reflect4;public class UserService { public boolean login(String name,String password){ if("admin".equals(name) && "123".equals(password)){ return true; } return false; } public void logout(){ System.out.println("系统已经安全退出！"); }} -
反编译Method
package Reflect4; import java.lang.reflect.Method; import java.lang.reflect.Modifier; public class ReflectTest09 { public static void main(String[] args) throws Exception{ StringBuilder s = new StringBuilder(); Class userServiceClass = Class.forName("java.lang.String"); s.append(Modifier.toString(userServiceClass.getModifiers()) + " class "+userServiceClass.getSimpleName()+" {n"); Method[] methods = userServiceClass.getDeclaredMethods(); for(Method method : methods){ s.append("t"); s.append(Modifier.toString(method.getModifiers())); s.append(" "); s.append(method.getReturnType().getSimpleName()); s.append(" "); s.append(method.getName()); s.append("("); // 参数列表 Class[] parameterTypes = method.getParameterTypes(); for(Class parameterType : parameterTypes){ s.append(parameterType.getSimpleName()); s.append(","); } // 删除指定下标位置上的字符 if(parameterTypes.length > 0){ s.deleteCharAt(s.length() - 1); } s.append("){}n"); } s.append("}"); System.out.println(s); } } -
反射机制调用方法
package Reflect4; import java.lang.reflect.Method; public class ReflectTest10 { public static void main(String[] args) throws Exception{ // 不使用反射机制，调用方法 // 创建对象 UserService userService = new UserService(); // 调用方法 boolean loginSuccess = userService.login("admin","123"); System.out.println(loginSuccess ? "登录成功" : "登录失败"); // 使用反射机制来调用一个对象的方法 Class userServiceClass = Class.forName("Reflect4.UserService"); // 创建对象 Object obj = userServiceClass.newInstance(); // 获取Method Method loginMethod = userServiceClass.getDeclaredMethod("login", String.class, String.class); // 调用方法 Object retValue = loginMethod.invoke(obj, "admin","123123"); System.out.println(retValue); } }
五、反射Constructor
-
反编译Constructor
package Reflect5; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; public class ReflectTest11 { public static void main(String[] args) throws Exception{ StringBuilder s = new StringBuilder(); Class vipClass = Class.forName("java.lang.String"); s.append(Modifier.toString(vipClass.getModifiers())); s.append(" class "); s.append(vipClass.getSimpleName()); s.append("{n"); // 拼接构造方法 Constructor[] constructors = vipClass.getDeclaredConstructors(); for(Constructor constructor : constructors){ s.append("t"); s.append(Modifier.toString(constructor.getModifiers())); s.append(" "); s.append(vipClass.getSimpleName()); s.append("("); // 拼接参数 Class[] parameterTypes = constructor.getParameterTypes(); for(Class parameterType : parameterTypes){ s.append(parameterType.getSimpleName()); s.append(","); } // 删除最后下标位置上的字符 if(parameterTypes.length > 0){ s.deleteCharAt(s.length() - 1); } s.append("){}n"); } s.append("}"); System.out.println(s); } } -
反射机制调用构造方法
package Reflect5; import java.lang.reflect.Constructor; public class ReflectTest12 { public static void main(String[] args) throws Exception{ // 不使用反射机制怎么创建对象 Vip v1 = new Vip(); Vip v2 = new Vip(110, "CoolEr", "2000-01-01", true); // 使用反射机制怎么创建对象呢？ Class c = Class.forName("Reflect5.Vip"); // 调用无参数构造方法 Object obj = c.newInstance(); System.out.println(obj); // 调用有参数的构造方法怎么办？ // 第一步：先获取到这个有参数的构造方法 Constructor con = c.getDeclaredConstructor(int.class, String.class, String.class,boolean.class); // 第二步：调用构造方法new对象 Object newObj = con.newInstance(110, "jackson", "1990-10-11", true); System.out.println(newObj); // 获取无参数构造方法 Constructor con2 = c.getDeclaredConstructor(); Object newObj2 = con2.newInstance(); System.out.println(newObj2); } } -
获取父类和父接口
package Reflect5; public class ReflectTest13 { public static void main(String[] args) throws Exception{ // String举例 Class stringClass = Class.forName("java.lang.String"); // 获取String的父类 Class superClass = stringClass.getSuperclass(); System.out.println(superClass.getName()); // 获取String类实现的所有接口（一个类可以实现多个接口。） Class[] interfaces = stringClass.getInterfaces(); for(Class in : interfaces){ System.out.println(in.getName()); } } }
