概述

通过Java语言中的反射机制可以操作字节码文件，优点是类似于黑客，可以读和修改字节码文件。。Java反射相关的类在java.lang.reflect.*包下，具体来讲，包括：
①java.lang.Class;代表字节码文件
②java.lang.reflect.Method;方法字节码
③java.lang.reflect.Constructor;构造器字节码
④java.lang.reflect.Field属性字节码

  1. package reflect;
  3. /**
  4.  * 字节码文件中的xxx字节码
  5.  */
  6. //Class文件代表整个字节码文件
  7. public class User {
  8.     //Field字节码，即属性字节码
  9.     int no;
  11.     //Constructor字节码，即构造器字节码
  12.     public User() {
  13.     }
  15.     //Method字节码，即方法字节码
  16.     public int getNo() {
  17.         return no;
  18.     }
  20.     public void setNo(int no) {
  21.         this.no = no;
  22.     }
  23. }

想要获得字节码文件中的属性、方法或者构造器，首先要获得字节码文件。

3种方式获得字节码文件

①Class.forName(“类名”);
Class c1 = Class.forName(“java.util.String”); //c1代表的是String.class
②对象.getClass()；
③包括基本数据类型中在内的任何一种类型，都有.class属性：
Class c = String.class，c代表String类型 

  1. package reflect;
  3. /**
  4.  * 想要操作一个类的字节码，首先要获得这个类的字节码，有三种方式获得这个类的字节码文件(java.lang.Class)
  5.  */
  6. public class RefectTest01 {
  7.     public static void main(String[] args) throws ClassNotFoundException {
  8.         //方式一:c1，c2，c3是对应类的整个.class文件
  9.         Class c1 = Class.forName("java.lang.String");
  10.         Class c2 = Class.forName("java.util.Date");
  11.         Class c3 = Class.forName("java.lang.System");
  13.         //方式二：java中任何一个对象都有getClass()方法，旨在获取该对象所在的类
  14.         String s = "abc";
  15.         Class x = s.getClass(); //x代表的是String.class字节码文件，x代表的是String类型
  16.         System.out.println(c1 == x);    //true
  18.         //方式三：java语言中，任何一种类型，包括基本数据类型，都有.class属性
  19.         Class str = String.class;   //str代表String类型
  20.         System.out.println(c1 == str);  //true
  21.     }
  23. }

反射 - 图1

获得Class，能做什么？

获取对象

  1. package reflect.bean;
  3. public class User {
  4.     public User(){
  5.         System.out.print("无参构造方法执行了！"+"\t");
  6.     }
  7.     //若没有无参构造方法，对象.newInstance()会出现实例化异常
  8. }
  15. package reflect;
  17. /**
  18.  * 获取到Class之后，能做什么？
  19.  * 通过Class的newInstance方法来实例化对象。
  20.  * 注意：newInstance方法内部实际上调用了无参构造器，所以必须保证无参构造器存在才行
  21.  * 那么问题来了：这种方式创建对象和常规方法相比，优势在哪？
  22.  */
  23. public class ReflectTest02 {
  25.     //通过反射机制获取Class，通过Class来实例化对象
  26.     public static void main(String[] args) {
  28.         //使用反射机制创建对象
  29.         try {
  30.             Class c1 = Class.forName("reflect.bean.User");
  31.             //这个方法会调用User这个类的无参构造方法，完成对象的创建
  32.             Object obj = c1.newInstance();
  33.             System.out.println(obj);    //无参构造方法执行了！    reflect.bean.User@1b6d3586
  34.         } catch (ClassNotFoundException e) {
  35.             e.printStackTrace();
  36.         } catch (IllegalAccessException e) {
  37.             e.printStackTrace();
  38.         } catch (InstantiationException e) {
  39.             e.printStackTrace();
  40.         }
  42.         //不使用反射机制创建对象
  43.         User user = new User();
  44.         System.out.println(user);   //reflect.User@4554617c
  45.     }
  47. }

如何体现发射机制的优越性？

在IDEA中创建以上文件，布局如右图：image.png

  1. package reflect;
  3. import java.io.FileReader;
  4. import java.io.IOException;
  5. import java.util.Properties;
  7. /**
  8.  * 验证反射机制的灵活性：
  9.  * Java代码写一遍，在不改变代码的基础上，可以做到不同对象的实例化，这就体现了反射的灵活性
  10.  * 符合OCP原则：对扩展开放，对修改关闭
  11.  * 高级框架例如：SSM、SSH的底层都使用了反射机制
  12.  */
  13. public class ReflectTest03 {
  14.     public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, InstantiationException {
  15.         //用IO流读取classinfo.properties文件
  16.         FileReader fr = new FileReader("D:\\DataValue\\project\\MyData\\Data1\\src\\reflect\\classinfo.properties");
  17.         //创建属性类对象
  18.         Properties pro = new Properties();
  19.         //加载
  20.         pro.load(fr);
  21.         //关闭流
  22.         fr.close();
  23.         //通过key获取value
  24.         String className = pro.getProperty("className");
  25.         System.out.println(className);  //reflect.User
  27.         //通过反射机制实例化对象
  28.         Class c2 = Class.forName(className);
  29.         Object obj = c2.newInstance();
  30.         System.out.println(obj);    //reflect.User@1b6d3586
  32.         //以上代码不改，改配置文件的className，改为：java.util.Date
  33.         //输出为：
  34.         // java.util.Date
  35.         // Thu Oct 14 08:00:56 CST 2021
  36.     }
  37. }

Class.forName()的作用

  1. package reflect;
  3. /*
  4. 研究一下，Class.forName()发生了什么？
  5. Class.forName()这个方法的执行会导致类加载，类加载时静态代码块会执行！
  6.  */
  7. public class ReflectTest04 {
  8.     public static void main(String[] args) throws ClassNotFoundException {
  9.         Class.forName("reflect.MyClass");   //静态代码块执行了！
  10.     }
  11. }
  13. class MyClass{
  14.     //静态代码块在类加载时执行，且只执行一次
  15.     static {
  16.         System.out.println("静态代码块执行了！");
  17.     }
  18. }

获取类路径下文件的绝对路径

  1. package reflect;
  3. /*
  4. 研究一下文件路径的问题
  5. 相对路径的缺点：可移植性差，换个编译工具，可能就找不到该文件了
  6.  */
  7. public class AboutPathTest {
  8.     public static void main(String[] args) {
  10.         //方式一
  11.         //使用以下方式的前提是，这个文件必须在类路径(src，src是类的根路径)下--Tcggg
  12.         //当前线程对象的类加载器的根路径下加载资源获取绝对路径
  13.         //这种方式获取绝对路径是通用的，不管是在哪个盘，什么系统
  14.         String path = Thread.currentThread().getContextClassLoader().getResource("reflect/classinfo.properties").getPath();
  15.         //  /D:/DataValue/project/MyData/Data1/out/production/Data1/reflect/classinfo.properties
  16.         //起点类的根路径
  17.         System.out.println(path);
  19.         //方式二：以流的形式返回
  20. /*        String path1 = Thread.currentThread().getContextClassLoader().getResource("").getPath();
  21.         FileReader fileReader = new FileReader(path1);*/
  22.         //以上2行可以合并为以下这行，直接以流形式返回
  23.         InputStream reader = Thread.currentThread().getContextClassLoader().getResourceAsStream("reflect/classinfo.properties");
  25.         Properties pro = new Properties();
  26.         pro.load(reader);
  27.         reader.close();
  28.         String className = pro.getProperty("className");
  29.         System.out.println(className);  //java.util.Date
  30.     }
  31. }

获取属性配置文件的内容

类及其他文件布局如下图：
image.png

  1. package reflect.bean;
  3. public class User {
  4.     String name;
  6.     public User(String name) {
  7.         this.name = name;
  8.     }
  9. }
  1. package reflect;
  3. import java.util.ResourceBundle;
  5. /*
  6. java.util包下提供了一个资源绑定器，便于获取属性配置文件中的内容
  7. 使用以下这种方式的时候，属性配置文件xxx.properties必须放到类路径下
  8.  */
  9. public class ResourceBundleTest {
  10.     public static void main(String[] args) {
  11.         //资源绑定器，只能绑定xxx.properties文件。并且这个文件必须在类路径下，文件扩展名也必须是properties
  12.         //并且在写路径的时候，路径后面的扩展名不能写
  13.         //总之三个要求：①src目录下    ②文件是属性配置文件    ③后缀名不能写
  14.         ResourceBundle bundle = ResourceBundle.getBundle("classinfo");
  15.         String className = bundle.getString("className");
  16.         System.out.println(className);  //reflect.bean.User
  17.     }
  18. }

类加载器概述

类加载器是负责专门加载类的命令或是工具，jdk自带的有3种类加载器：

  1.   - 启动类加载器(父)
  2.   - 扩展类加载器(母)
  3.   - 应用类加载器

父和母被称为双亲委派机制。先父后母，即如果你写了String类，Sun公司自己也有String类，按这个机制来，优先加载Sun公司写的String类。这是为了类加载的安全而设置的双亲委派机制。
假设有这样一段代码：String s = “abc”;
在代码开始执行之前，会将所需的类全部加载到JVM中。那么是怎么进行加载的呢？首先是启动类加载器去加载，加载的对象是jdk目录下jdk/jre/lib/rt.jar。（注：rt.jar中的都是JDK最核心的类库。）
如果通过启动类加载器加载不到，会通过扩展类加载器去加载。注意：扩展类加载器专门加载jre/lib/ext.jar。
如果扩展类加载器也没加载到，就会通过应用类加载器加载，这里加载的是classpath中的类(class文件).

获取属性对象

  1. package reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Modifier;
  6. /*
  7. 反射Student类中所有的Field
  8.  */
  9. public class ReflectTest05 {
  10.     public static void main(String[] args) throws ClassNotFoundException {
  11.         //获取整个类
  12.         Class studentClass = Class.forName("reflect.bean.Student");
  13.         String className = studentClass.getName();
  14.         System.out.println(className);  //reflect.bean.Student
  15.         String simpleName = studentClass.getSimpleName();
  16.         System.out.println(simpleName); //Student
  18.         //获取类中所有public 修饰的Field
  19.         Field[] fields = studentClass.getFields();
  20.         System.out.println(fields.length);  //1
  21.         //取出这个Field
  22.         Field f = fields[0];
  23.         //取出这个Field的名字
  24.         String fieldName = f.getName();
  25.         System.out.println(fieldName);  //no
  27.         //获取类中所有Field
  28.         Field[] fs = studentClass.getDeclaredFields();
  29.         System.out.println("------------------------------------");
  30.         System.out.println(fs.length);  
  31.         for (Field field : fs) {
  32.             //获取属性的修饰符列表
  33.             //返回的修饰符是一个数字，每个数字是修饰符的代号
  34.             int i = field.getModifiers();
  35. //            System.out.println(i);
  36.             //可以将这个代号数字转换为“字符串”吗？
  37.             String modifierStr = Modifier.toString(i);
  38.             System.out.print(modifierStr+" ");
  40.             //获取属性的类型
  41.             Class fieldType = field.getType();
  42. //            String fieldTypeName = fieldType.getName();
  43. //            System.out.println(fieldTypeName);
  44.             String fieldTypeSimpleName = fieldType.getSimpleName();
  45.             System.out.print(fieldTypeSimpleName+" ");
  47.             //获取属性的名字
  48.             System.out.println(field.getName());
  49.         }
  51.     }
  52. }
  53. /*
  54. 整体内容输出如下：
  55.     ------------------------------------
  56.     5
  57.     private String name
  58.     protected int age
  59.      boolean gender
  60.     public int no
  61.     public static final double MATH_PI
  62.  */

反编译之Student类

  1. package reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Modifier;
  6. /*
  7. 反编译Student这个Bean类
  8. 只需要提供全类名
  9.  */
  10. public class ReflectTest06 {
  11.     public static void main(String[] args) throws Exception{
  12.         Class studentClass = Class.forName("reflect.bean.Student");
  13.         StringBuilder s = new StringBuilder();
  14.         s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + "{\n");
  15.         Field[] fields = studentClass.getDeclaredFields();
  16.         for (Field field : fields) {
  17.             s.append("\t");
  18.             s.append(Modifier.toString(field.getModifiers())+" "+field.getType().getSimpleName()+" "+field.getName()+";\n");
  20.         }
  21.         s.append("}");
  22.         System.out.println(s);
  23.     }
  24. }
  25. /*
  26. 反编译Students类的输出结果：
  27. public class Student{
  28.     private String name;
  29.     protected int age;
  30.      boolean gender;
  31.     public int no;
  32.     public static final double MATH_PI;
  33. }
  34.  */

反编译之Date类

  1. package reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Modifier;
  6. public class ReflectTest06 {
  7.     public static void main(String[] args) throws Exception{
  8.         Class studentClass = Class.forName("java.util.Date");
  9.         StringBuilder s = new StringBuilder();
  10.         s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + "{\n");
  11.         Field[] fields = studentClass.getDeclaredFields();
  12.         for (Field field : fields) {
  13.             s.append("\t");
  14.             s.append(Modifier.toString(field.getModifiers())+" "+field.getType().getSimpleName()+" "+field.getName()+";\n");
  16.         }
  17.         s.append("}");
  18.         System.out.println(s);
  19.     }
  20. }
  21. /*
  22. 反编译Students类的输出结果：
  23. public class Date{
  24.     private static final BaseCalendar gcal;
  25.     private static BaseCalendar jcal;
  26.     private transient long fastTime;
  27.     private transient Date cdate;
  28.     private static int defaultCenturyStart;
  29.     private static final long serialVersionUID;
  30.     private static final String[] wtb;
  31.     private static final int[] ttb;
  32. }
  33.  */

反编译之String类

  1. package reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Modifier;
  6. public class ReflectTest06 {
  7.     public static void main(String[] args) throws Exception{
  8.         Class studentClass = Class.forName("java.lang.String");
  9.         StringBuilder s = new StringBuilder();
  10.         s.append(Modifier.toString(studentClass.getModifiers()) + " class " + studentClass.getSimpleName() + "{\n");
  11.         Field[] fields = studentClass.getDeclaredFields();
  12.         for (Field field : fields) {
  13.             s.append("\t");
  14.             s.append(Modifier.toString(field.getModifiers())+" "+field.getType().getSimpleName()+" "+field.getName()+";\n");
  16.         }
  17.         s.append("}");
  18.         System.out.println(s);
  19.     }
  20. }
  21. /*
  22. 反编译Students类的输出结果：
  23. public final class String{
  24.     private final char[] value;
  25.     private int hash;
  26.     private static final long serialVersionUID;
  27.     private static final ObjectStreamField[] serialPersistentFields;
  28.     public static final Comparator CASE_INSENSITIVE_ORDER;
  29. }
  30.  */

外部修改属性值

  1. package reflect.bean;
  3. import java.lang.reflect.Field;
  5. /*
  6. 通过反射机制去访问对象属性，包括对对象属性值的获取和修改
  7. 这种方法的好处是能写到配置文件中，能发挥反射机制的灵活性
  8.  */
  9. public class ReflectTest07 {
  10.     public static void main(String[] args) throws Exception{
  11.         Class studentClass = Class.forName("reflect.bean.Student");
  12.         //注意：这个obj就是Student对象。效果等同  Student student = new Student();中的student
  13.         Object obj = studentClass.newInstance();
  14.         //获取no属性，属性之间是按照属性名来区分的
  15.         Field noField = studentClass.getDeclaredField("no");
  16.         //给obj对象的no属性赋值
  17.         /*
  18.         虽然使用了反射机制，但是三要素还是缺一不可的：
  19.         要素1：obj对象
  20.         要素2：no属性
  21.         要素3：属性值2222
  22.          */
  23.         noField.set(obj,2222);
  24.         //读取属性的值：2个要素：①对象   ②属性
  25.         System.out.println(noField.get(obj));   //2222
  27.         //可以从外部修改私有的属性吗
  28.         Field nameField = studentClass.getDeclaredField("name");
  29.         //打破封装！！！可能会给不法分子留下机会
  30.         nameField.setAccessible(true);
  31.         nameField.set(obj,"jackson");
  32.         System.out.println(nameField.get(obj));
  34.     }
  35. }

获取对象方法

先定义一个类，然后通过反射去拿取这个类的所有方法(签名)

  1. package reflect.service;
  3. /*
  4. 用户业务类
  5.  */
  6. public class UserService {
  7.     public boolean login(String name,String password){
  8.         if ("admin".equals(name)&&"123".equals(password)){
  9.             return true;
  10.         }
  11.         return false;
  12.     }
  14.     public void logout(){
  15.         System.out.println("系统已经安全退出");
  16.     }
  17. }
  1. package reflect;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Modifier;
  6. /*
  7. 反射获取对象的方法
  8.  */
  9. public class ReflectTest08 {
  10.     public static void main(String[] args) throws Exception{
  11.         Class userServiceClass = Class.forName("reflect.service.UserService");
  12.         //获取对象的所有方法
  13.         Method[] declaredMethods = userServiceClass.getDeclaredMethods();
  14.         //下面对方法进行遍历：
  15.         for (Method declaredMethod : declaredMethods) {
  16.             //获取方法的修饰符列表
  17.             System.out.println(Modifier.toString(declaredMethod.getModifiers()));
  18.             //获取方法的返回值类型
  19.             System.out.println(declaredMethod.getReturnType());
  20.             //获取方法名
  21.             System.out.println(declaredMethod.getName());
  22.             //获取方法的参数列表
  23.             Class[] parameterTypes = declaredMethod.getParameterTypes();
  24.             for (Class parameterType : parameterTypes) {
  25.                 System.out.println(parameterType.getSimpleName());
  26.             }
  27.         }
  28.     }
  29. }
  30. /*
  31. 结果输出：
  32. public
  33. void
  34. logout
  35. public
  36. boolean
  37. login
  38. String
  39. String
  40.  */

可变长参数

  1. package reflect;
  3. /*
  4. 可变长度参数
  5. int... args
  6. 语法格式：类型...（注意，是3个点）
  7. 1.可变长参数的参数个数是0-n个
  8. 2.可变长参数必须在参数列表中的最后一个，且只能有一个可边长参数
  9. 3.可变长参数
  10.  */
  11. public class ArgsTest {
  12.     public static void main(String[] args) {
  13.         m();    //m方法执行了...
  14.         m(10);  //m方法执行了...
  15.         m(10,20,30,40); //m方法执行了...
  17.         m3("ab","cd","ef"); //ab    cd    ef
  18.         //可以传一个数组
  19.         String[] strs = {"a","b","c"};
  20.         m3(strs);   //a     b    c
  21.         m3(new String[]{"我","是","中","国","人"});//我    是    中    国    人    
  22.     }
  24.     public static void m(int... args){
  25.         System.out.println("m方法执行了...");
  26.     }
  28.     public static void m3(String... args){
  29.         //args有length属性，说明args是一个数组
  30.         //
  31.         for (int i = 0; i < args.length; i++) {
  32.             System.out.print(args[i]+"\t");
  33.         }
  34.     }
  35. }

反编译对象的方法

  1. package reflect.service;
  3. /*
  4. 用户业务类
  5.  */
  6. public class UserService {
  7.     public boolean login(String name,String password){
  8.         if ("admin".equals(name)&&"123".equals(password)){
  9.             return true;
  10.         }
  11.         return false;
  12.     }
  14.     public void logout(){
  15.         System.out.println("系统已经安全退出");
  16.     }
  17. }
  1. package reflect;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Modifier;
  6. /*
  7. 反编译方法签名
  8. public class UserService {
  9.     public boolean login(String name,String password){}
  10. }
  11.  */
  12. public class ReflectTest09 {
  13.     public static void main(String[] args) throws Exception{
  14.         StringBuilder s = new StringBuilder();
  15.         Class userServiceClass = Class.forName("reflect.service.UserService");
  16.         s.append(Modifier.toString(userServiceClass.getModifiers()));
  17.         s.append(" class ");
  18.         s.append(userServiceClass.getSimpleName()+"{\n");
  20.         Method[] declaredMethods = userServiceClass.getDeclaredMethods();
  21.         //public boolean login(String name,String password){}
  22.         for (Method declaredMethod : declaredMethods) {
  23.             s.append("  "+Modifier.toString(declaredMethod.getModifiers()));
  24.             s.append(" "+declaredMethod.getReturnType()+" ");
  25.             s.append(declaredMethod.getName());
  26.             s.append("(");
  28.             Class[] parameterTypes = declaredMethod.getParameterTypes();
  29.             for (Class parameterType : parameterTypes) {
  30.                 s.append(parameterType.getSimpleName());
  31.                 s.append(",");
  32.             }
  33.             s.deleteCharAt(s.length()-1);
  34.             s.append("){}\n");
  35.         }
  37.         s.append("}");
  38.         System.out.println(s);
  39.     }
  40. }
  41. /*
  42. 输出如下：
  43. public class UserService{
  44.   public void logout){}
  45.   public boolean login(String,String){}
  46. }
  47.  */

访问或者修改对象的方法

  1. package reflect.service;
  3. /*
  4. 用户业务类
  5.  */
  6. public class UserService {
  7.     public boolean login(String name,String password){
  8.         if ("admin".equals(name)&&"123".equals(password)){
  9.             return true;
  10.         }
  11.         return false;
  12.     }
  14.     public void logout(){
  15.         System.out.println("系统已经安全退出");
  16.     }
  17. }
  1. package reflect;
  3. import reflect.service.UserService;
  4. import java.lang.reflect.Method;
  6. /*
  7. ★★★★★重点：通过反射机制怎么去调用一个对象的方法？★★★★★
  8. 反射机制让代码具有通用性，把需要改变的东西写到配置文件里，灵活
  9.  */
  10. public class ReflectTest10 {
  11.     public static void main(String[] args) throws Exception{
  13.         //不使用反射机制，如何调用方法？
  14.         UserService userService = new UserService();
  15.         boolean loginSuccess = userService.login("admin", "123");
  16.         System.out.println(loginSuccess);   //true
  18.         //通过反射机制如何调用对象的方法？
  19.         Class uService = Class.forName("reflect.service.UserService");
  20.         //创建对象
  21.         Object obj = uService.newInstance();
  22.         //获取Method(方法名和形参列表)
  23.         Method loginMethod = uService.getDeclaredMethod("login", String.class, String.class);
  24.         //反射方法四要素：对象、方法名、实参、返回值
  25.         Object retValue = loginMethod.invoke(obj, "admin", "123"); 
  26.         System.out.println(retValue); //true
  27.     }
  28. }

获取构造器信息

反编译构造器（烂尾工程）

  1. package reflect.bean;
  3. public class Vip {
  4.     int no;
  5.     String name;
  6.     String birth;
  7.     boolean gender;
  9.     public Vip(int no, String name, String birth, boolean gender) {
  10.         this.no = no;
  11.         this.name = name;
  12.         this.birth = birth;
  13.         this.gender = gender;
  14.     }
  16.     public Vip(int no, String name, String birth) {
  17.         this.no = no;
  18.         this.name = name;
  19.         this.birth = birth;
  20.     }
  22.     public Vip(int no, String name) {
  23.         this.no = no;
  24.         this.name = name;
  25.     }
  27.     public Vip(int no) {
  28.         this.no = no;
  29.     }
  31.     public Vip() {
  32.     }
  33. }
  1. package reflect;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Modifier;
  6. /*
  7. 反编译一个类的Constructor构造方法
  8.  */
  9. public class ReflectTest11 {
  10.     public static void main(String[] args) throws Exception{
  11.         //public class Vip{}
  12.         StringBuilder s = new StringBuilder();
  13.         Class vipClass = Class.forName("reflect.bean.Vip");
  14.         s.append(Modifier.toString(vipClass.getModifiers())+" class ");
  15.         s.append(vipClass.getSimpleName()+"(");
  17. //        Constructor[] declaredConstructors = vipClass.getDeclaredConstructors();
  18. //        for (Constructor declaredConstructor : declaredConstructors) {
  19. //            s.append("{\n\t"+Modifier.toString(declaredConstructor.getModifiers())+" class ");
  20. //            s.append(vipClass.getSimpleName()+"(");
  21. //
  22. //            s.append(")\n");
  23. //        }
  26.         s.append("){");
  27.         s.append("}");
  28.         s.append("\n}");
  29.         System.out.println(s);
  30.     }
  31. }

用反射初始化对象

  1. package reflect.bean;
  3. public class Vip {
  4.     int no;
  5.     String name;
  6.     String birth;
  7.     boolean gender;
  9.     public Vip(int no, String name, String birth, boolean gender) {
  10.         this.no = no;
  11.         this.name = name;
  12.         this.birth = birth;
  13.         this.gender = gender;
  14.     }
  16.     public Vip(int no, String name, String birth) {
  17.         this.no = no;
  18.         this.name = name;
  19.         this.birth = birth;
  20.     }
  22.     public Vip(int no, String name) {
  23.         this.no = no;
  24.         this.name = name;
  25.     }
  27.     public Vip(int no) {
  28.         this.no = no;
  29.     }
  31.     public Vip() {
  32.     }
  34.     @Override
  35.     public String toString() {
  36.         return "Vip{" +
  37.                 "no=" + no +
  38.                 ", name='" + name + '\'' +
  39.                 ", birth='" + birth + '\'' +
  40.                 ", gender=" + gender +
  41.                 '}';
  42.     }
  43. }
  1. package reflect;
  3. import reflect.bean.Vip;
  4. import java.lang.reflect.Constructor;
  5. /*
  6. 使用反射机制创建对象
  7.  */
  8. public class ReflectTest12 {
  9.     public static void main(String[] args) throws Exception{
  10.         //不使用反射机制怎么创建对象？
  11.         Vip v1 = new Vip();
  12.         Vip v2 = new Vip(110, "zhangsan", "2001-10-1", true);
  14.         //使用反射机制怎么创建对象
  15.         //无参
  16.         Class vipClass = Class.forName("reflect.bean.Vip");
  17.         Object obj1 = vipClass.newInstance();
  18.         //有参
  19.         //第一步，先获取到这个有参数的构造方法
  20.         Constructor constructor = vipClass.getDeclaredConstructor(int.class, String.class, String.class, boolean.class);
  21.         //第二步，调用构造方法new对象
  22.         Object obj2 = constructor.newInstance(110, "lisi", "1996-7-10", false);
  23.         System.out.println("obj1:" + obj1 + "\nobj2:" + obj2);
  24.     }
  25. }
  26. //输出：
  27. //obj1:Vip{no=0, name='null', birth='null', gender=false}
  28. //obj2:Vip{no=110, name='lisi', birth='1996-7-10', gender=false}

获取一个类的父类及其实现的所有接口

  1. package reflect;
  2. /*
  3. 给你一个类，如何获取这个类的父类，以及实现了哪些接口？
  4.  */
  5. public class ReflectTest13 {
  6.     public static void main(String[] args) throws Exception{
  7.         //以String举例
  8.         Class stringClass = Class.forName("java.lang.String");
  10.         //获取String类的父类
  11.         Class superclass = stringClass.getSuperclass();
  12.         System.out.println(superclass.getName());//java.lang.Object
  14.         //获取String类所实现的所有接口（一个类可以实现多个接口）
  15.         Class[] interfaces = stringClass.getInterfaces();
  16.         for (Class anInterface : interfaces) {
  17.             System.out.println(anInterface.getName());
  18.         }
  19.         //java.io.Serializable
  20.         //java.lang.Comparable
  21.         //java.lang.CharSequence
  22.     }
  23. }

重点笔记

  1. Class studentClass = Class.forName("reflect.bean.Student");
  2. Field nameField = studentClass.getDeclaredField("name");
  3. //打破封装！！！可能会给不法分子留下机会
  4. nameField.setAccessible(true);
  5. nameField.set(obj,"jackson");
  9. Class uService = Class.forName("reflect.service.UserService");
  10. Method loginMethod = uService.getDeclaredMethod("login", String.class, String.class);
  11. Object obj = uService.newInstance();
  12. //反射方法四要素：对象、方法名、实参、返回值
  13. Object retValue = loginMethod.invoke(obj, "admin", "123"); 
  17. Class vipClass = Class.forName("reflect.bean.Vip");
  18. Constructor constructor = vipClass.getDeclaredConstructor(int.class, String.class, String.class, boolean.class);
  19. //第二步，调用构造方法new对象
  20. Object obj2 = constructor.newInstance(110, "lisi", "1996-7-10", false);