JavaSE进阶 | 反射机制（反射Method、Constructor、Field）

今天药忘吃喽~ 2024-04-07 11:36 119阅读 0赞

目录

一：反射Field

  1. 获取Field

  2. 反编译Field（了解）

  3. 通过反射机制访问对象的属性（重点）

二：反射Method

  1. 可变长度参数

  2. 获取Method（了解）

  3. 反编译Method(了解)

  4. 通过反射机制调用方法（重点）

三：反射Constructor

  1. 反编译Constructor

  2. 反射机制调用构造方法（了解）

  3. 补充：获取父类和父类的接口（重点）

在学习之前，先牢记几个常用的英语单词代表的意思：

（1）class：类

（2）Method：普通的方法

（3）Constructor：构造方法

（4）Field：属性

（5）Modifiers：修饰符列表

（6）Type：修饰的类型
（7）Name：名字

（8）ReturnType：返回值值类型

（9）parameterType：参数的类型

一：反射Field

1. 获取Field

首先调用Class.forName(“完整类名”)，获取整个类；对于类也可以调用getName()方法获取完整类名，或者调用getSimpleName()方法获取简单类名。

第一种：调用getFields()方法，获取类中所有的public(公开的)修饰的Field（属性），返回的是一个Field数组；然后再调用getName()方法，得到属性的名字！

第二种：调用getDeclaredFields()方法，获取所有的Field（属性），得到一个Field数组，遍历这个数组，拿到每一个属性，调用对应的方法就可以得到每一个属性的：属性的修饰符列表(Modifiers)、属性的类型(Type)、属性的名字(Name)

（1）调用getModifiers()方法，返回的是一个代号，是int类型；在调用Modifier.toString()静态方法，把int值传进去，就可以转换成字符串；得到属性的修饰符列表

（2）调用getType()方法返回的是一个Class类型，然后在调用getSimpleName()方法得到String类型，得到属性的类型

（3）直接调用getName()方法，返回一个String类型，就能得到属性的名字 

  1. package com.bjpowernode.java.reflect;
  3. import java.lang.reflect.Field;
  4. import java.lang.reflect.Modifier;
  6. // 反射Student类中的所有Field
  7. public class ReflectTest06 {
  8.     public static void main(String[] args) throws Exception{
  9.         // 获取整个类
  10.         Class studentClass = Class.forName("com.bjpowernode.java.reflect.Student");
  12.         // 补充：studentClass也有getName()方法
  13.         String studentName = studentClass.getName();
  14.         System.out.println("完整类名："+studentName); // com.bjpowernode.java.reflect.Student
  15.         String simpleName = studentClass.getSimpleName();
  16.         System.out.println("简单类名"+simpleName); // Student
  18.         // 1、 获取类中所有的public(公开的)修饰的Field（属性）
  19.         Field[] fields = studentClass.getFields();
  20.         System.out.println(fields.length); //1 测试数组中只有1个元素
  21.         // 取出这个Field
  22.         Field field = fields[0];
  23.         // 取出这个Field的名字
  24.         String fieldName = field.getName();
  25.         System.out.println(fieldName); // no（只有这个是public修饰的）
  27.         // 2、获取所有的Field
  28.         Field[] fields1 = studentClass.getDeclaredFields();
  29.         System.out.println(fields1.length); // 4
  30.         // 遍历
  31.         for(Field field1 :fields1){
  32.             // 2.1 获取属性的修饰符列表
  33.             // 用Modifiers()而不是Modifier，因为修饰符可能有多个
  34.             // 返回的是一个整型数字，每个数字是修饰符的代号
  35.             // 然后调用静态方法Modifier.toString(int) 把数字准换成对应的修饰符字符串
  36.             int i = field1.getModifiers();
  37.             String modifier = Modifier.toString(i);
  38.             System.out.println(modifier);
  40.             //2.2 获取属性的类型，field1.getType()返回的是一个Class
  41.             Class fieldType = field1.getType();
  42.             String fName = fieldType.getSimpleName();
  43.             System.out.println(fName); // int  String int boolean
  45.             //2.3 获取属性的名字, field1.getName()返回的是一个String
  46.             System.out.println(field1.getName()); //no name  age  sex
  48.         }
  50.     }
  51. }
  53. // 反射属性
  54. class Student{
  55.     // 4个Field，分别采用了不同的访问控制权限修饰符
  56.     public int no; // Field对象
  57.     private String name; // Field对象
  58.     protected int age;
  59.     boolean sex;
  60.     public static final double MATH_PI = 3.1415926; // 修饰符有多个
  61. }

2. 反编译Field（了解）

通过反射机制，反编译一个类的属性Field；知道类的完整类名，就可以反编译该类的信息；主要运用的是字符串拼接的知识点。

  1. package com.bjpowernode.java.reflect;
  2. import java.lang.reflect.Field;
  3. import java.lang.reflect.Modifier;
  5. // 反编译Field
  6. public class ReflectTest07 {
  7.     public static void main(String[] args) throws Exception {
  8.        // 创建字符串拼接
  9.        StringBuilder s = new StringBuilder();
  11.        // 获取整个类
  12.         Class studentClass = Class.forName("com.bjpowernode.java.reflect.Student");
  14.         // 字符串拼接
  15.         //s.append("public class Student{");
  16.         // 采用动态获取的方式
  17.         s.append(Modifier.toString(studentClass.getModifiers()) + 
  18.         " class " + studentClass.getSimpleName() + "{\n");
  20.         // 获取所有的属性
  21.         Field[] fields = studentClass.getDeclaredFields();
  22.         for (Field field :fields){
  23.             // 追加修饰符
  24.             s.append("\t");
  25.             s.append(Modifier.toString(field.getModifiers()));
  26.             s.append(" ");
  27.             // 追加类型
  28.             s.append(field.getType().getSimpleName());
  29.             s.append(" ");
  30.             // 追加名字
  31.             s.append(field.getName());
  32.             s.append(";\n");
  34.         }
  36.         s.append("}");
  38.         System.out.println(s);
  40.     }
  41. }

3. 通过反射机制访问对象的属性（重点）

（1）怎么通过反射机制访问一个java对象的属性？
①给属性赋值使用“属性.set(对象，值)”

②获取属性的值使用“属性.get(对象)”。

（2）调用c.getDeclaredFields()无参方法，返回的是一个Field[] 数组；调用c.getDeclaredField(String name)有参方法，根据属性的名称拿到一个Field，返回的是一个指定字符串的Field属性；有了指定的属性，就可以调用get和set方法进行修改和取出值了

（3）对于private私有的属性也是可以取到并修改的，但是需要**先调用setAccessible(true)方法打破封装**，然后就可以调用了。

（4）反射机制的缺点：打破封装，在外部也是可以访问私有private修饰的变量；造成数据不安全

详细步骤：

第一步：通过类加载获取整个类，Class.forName(“完整类型”)；

第二步：给属性赋值需要三要素：对象.属性 = 值；例如：s.no = 19；所以需要创建对象

第三步：调用getDeclaredField(属性名)方法，返回的是一个特定的Field属性对象

第四步：调用“Field属性对象.set(对象,值)”方法，完全符合属性赋值三要素，完成属性的赋值；调用“Field属性对象.get(对象)”完成取

补充：对于private修饰的属性，要想访问或者修改，必须调用“Field属性对象.setAccessible(true)”先打破封装！

  1. package com.bjpowernode.java.reflect;
  3. import java.lang.reflect.Field;
  5. public class ReflectTest08 {
  6.     public static void main(String[] args) throws Exception {
  7.         // 1. 不使用反射机制，怎么去访问一个对象的属性呢？
  8.         Student s = new Student();
  9.         // 2. 给属性赋值
  10.         s.no = 1111;
  11.         //三要素：给s对象的no属性赋值1111
  12.         // 要素1：对象s    要素2：no属性    要素3：值1111
  13.         // 3.  读属性值
  14.         // 两个要素：获取s对象的no属性的值。
  15.         System.out.println(s.no); // 对象.属性
  18.         // 1.使用反射机制（set get）
  19.             // 获取类
  20.         Class studentClass = Class.forName("com.bjpowernode.java.reflect.Student");
  21.             // 创建对象
  22.         Object obj = studentClass.newInstance(); // Student对象
  24.         // 2.获取no属性（根据属性的名称来获取Field）
  25.         Field noField = studentClass.getDeclaredField("no");
  26.         // 3.给obj对象(Student对象)的no属性赋值
  27.          /*
  28.         虽然使用了反射机制，但是三要素还是缺一不可：
  29.             要素1：obj对象
  30.             要素2：no属性
  31.             要素3：2222值
  32.         注意：反射机制让代码复杂了，但是为了一个“灵活”，这也是值得的。
  33.          */
  34.         noField.set(obj,222);// 给obj对象的no属性赋值2222
  35.         // 4. 读取属性的值
  36.         // 两个要素：获取obj对象的no属性的值。
  37.         System.out.println(noField.get(obj)); // 属性.get(对象)
  40.         // 2.可以反问私有的属性name吗？(需要打破封装才可以访问)
  41.         Field nameField = studentClass.getDeclaredField("name");
  43.         // 打破封装（反射机制的缺点：打破封装，造成数据不安全）
  44.         // 这样设置完之后，在外部也是可以访问私有private的。
  45.         nameField.setAccessible(true);
  47.         // 给name属性赋值
  48.         nameField.set(obj,"zhangsan");
  49.         // 获取name属性的值
  50.         System.out.println(nameField.get(obj)); // zhangsan
  52.     }
  53. }

注：对于static修饰的静态的属性访问我们不需要对象，是通过类来调用的；例如：nameField.set(Student.class,”zhangsan”)。如果传一个null也是可以的，因为我们原本需要的就是一个对象，而静态方法的调用又不需要对象，是通过类，所以传null也可以！

二：反射Method

1. 可变长度参数

（1）什么是可变长度参数？

例如：int… args 这就是可变长度参数
（2）语法是：类型… （注意：一定是3个点）

①可变长度参数要求的参数个数是：0~N个。
②可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有1个。
③可变长度参数可以当做一个数组来看待，有length属性。

  1. package com.bjpowernode.java.reflect;
  3. public class ArgsTest {
  4.     public static void main(String[] args) {
  5.        // 1.不带参数 一个参数 两个参数...都可以正常执行（参数可变）
  6.        m();
  7.        m(100);
  8.        m(10,20);
  10.        m2(100);
  11.        m2(10,"abc");
  13.        m3("abc","def","dd");
  14.        // 里面也可以传一个数组进去
  15.        String[] str = {"aaa","bb","c"};
  16.        m3(str);
  18.     }
  19.     // 带有可变长度的方法
  20.     public static void m(int... args){
  21.         System.out.println("m方法执行了");
  22.     }
  24.     // 2.可变长度参数在参数列表中必须在最后一个位置上，而且可变长度参数只能有1个
  25.     //public static void m2(String... args1,int... args2){}
  26.     public static void m2(int a,String... args){
  27.         System.out.println("m2方法执行");
  28.     }
  30.     // 3.可变长度参数可以当做一个数组来看待
  31.     public static void m3(String... args){
  32.         // args有length属性，说明args是一个数组
  33.         for (int i = 0; i < args.length; i++) {
  34.             System.out.println(args[i]);
  35.         }
  36.     }
  38. }

2. 获取Method（了解）

UserService类

  1. package com.bjpowernode.java.reflect;
  2. // 用户登录类
  3. public class UserService {
  4.     /**
  5.      * 登录方法
  6.      * @param name 用户名
  7.      * @param password  用户密码
  8.      * @return 表示登录成功，false表示登录失败
  9.      */
  10.     public boolean login(String name,String password){
  11.         if("admin".equals(name) && "123".equals(password)){
  12.             return true;
  13.         }
  14.         return false;
  15.     }
  17.     /**
  18.      *  退出系统的方法
  19.      */
  20.     public void logout(){
  21.         System.out.println("退出系统");
  22.     }
  23. }

反射Method代码和反射Field的方式很相似，有个别的区别：

（1）调用的是getDeclaredMethods()方法，而不是getDeclaredFields()

（2）返回的是一个Method数组，而不是Field数组

（3）获取类型，这里是返回值类型，调用的是getReturnType方法，而不是getType方法

（4）最终多了一项参数类型：调用的是getParameterTypes() ，返回的是一个Class数组，然后在调用getSimpleName()方法，就可以拿到对应的参数类型。

  1. package com.bjpowernode.java.reflect;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Modifier;
  6. public class ReflectMethod {
  7.     public static void main(String[] args) throws Exception{
  8.         // 获取类
  9.         Class userServiceClass = Class.forName("com.bjpowernode.java.reflect.UserService");
  10.         // 获取所有的Method
  11.         Method[] methods =  userServiceClass.getDeclaredMethods();
  12.         for(Method method :methods){
  13.             // 1.获取修饰符列表
  14.             int i = method.getModifiers();
  15.             System.out.println(Modifier.toString(i));
  17.             // 2.获取方法的返回值类型
  18.             Class classMethod = method.getReturnType();
  19.             System.out.println(classMethod.getSimpleName());
  21.             // 3.获取方法名
  22.             System.out.println(method.getName()); //获取方法名：login logout
  24.             // 4.获取方法的参数类型(方法的参数可能有多个)
  25.             Class[] parameterTypes = method.getParameterTypes();
  26.             for(Class parameterType : parameterTypes){
  27.                 System.out.println(parameterType.getSimpleName());
  28.             }
  30.         }
  31.     }
  33. }

#

3. 反编译Method(了解)

通过这种方式，可以反编译一个类的方法

  1. package com.bjpowernode.java.reflect;
  3. import java.lang.reflect.Method;
  4. import java.lang.reflect.Modifier;
  6. public class ReflectMethodTest02 {
  7.     public static void main(String[] args) throws Exception {
  8.         StringBuilder s = new StringBuilder();
  9.         // 获取类
  10.         Class userServiceClass = Class.forName("java.lang.String");
  12.         // 追加
  13.         //s.append("public class UserService{");
  14.         // 采用动态获取的方式
  15.         s.append(Modifier.toString(userServiceClass.getModifiers())+" class "+userServiceClass.getSimpleName()+ "{\n");
  17.         // 获取方法
  18.         Method[] methods = userServiceClass.getDeclaredMethods();
  19.         for(Method method : methods){
  20.             s.append("\t");
  21.             // 追加修饰符
  22.             s.append(Modifier.toString(method.getModifiers()));
  23.             s.append(" ");
  24.             // 追加类型
  25.             s.append(method.getReturnType().getSimpleName());
  26.             s.append(" ");
  27.             // 追加方法名
  28.             s.append(method.getName());
  29.             // 追加参数类型
  30.             s.append("(");
  31.             Class[] parameterTypes = method.getParameterTypes();
  32.             for (Class parameterType :parameterTypes){
  33.                 s.append(parameterType.getSimpleName());
  34.                 s.append(",");
  35.             }
  37.             // 最后会多一个 ， 怎么删除？
  38.             // 方法1：删除指定下标位置上的字符
  39.             s.deleteCharAt(s.length()-1);
  41.             s.append("){}");
  42.             s.append("\n");
  43.         }
  45.         s.append("}");
  47.         System.out.println(s);
  48.     }
  49. }

4. 通过反射机制调用方法（重点）

重点：必须掌握，通过反射机制怎么调用一个对象的方法？

（1）通过反射机制访问对象的属性很相似，那是通过set和get方法进行修改和读取数据的；而通过反射机制调用方法，是通过invoke()方法进行传参调用的，用返回值作为数据的读出

（2）反射机制，让代码很具有通用性，可变化的内容都是写到配置文件当中，将来修改配置文件之后，创建的对象不一样了，调用的方法也不同了，但是java代码不需要做任何改动。这就是反射机制的魅力！

详细步骤：

第一步：通过类加载获取整个类，Class.forName(“完整类型”)；

第二步：调用方法四要素：对象、方法、参数、返回值，例如：int i = s.sum(10,20)；所以也需要创建对象；

第三步：调用getDeclaredMethod(“方法名”,参数1类型.class,参数2类型.class)返回的是一个特定的Method方法对象；

第四步：通过调用”Method方法对象.invoke(obj,参数1值,参数2值)”会得到一个返回值；完全满足调用方法四要素，可以正常完成方法的调用。

  1. package com.bjpowernode.java.reflect;
  3. import java.lang.reflect.Method;
  5. public class ReflectMethodTest03 {
  6.     public static void main(String[] args) throws Exception {
  7.         // 1.不使用反射机制调用方法
  8.         UserService userService = new UserService();
  9.         boolean login = userService.login("admin","123");
  10.         System.out.println(login?"登录成功":"登录失败");
  12.         // 2.使用反射机制来调用一个对象的方法
  13.         // 获取Class
  14.         Class userServiceClass = Class.forName("com.bjpowernode.java.reflect.UserService");
  15.         // 创建对象
  16.         Object obj = userServiceClass.newInstance();
  17.         // 获取方法（通过方法名和参数区分方法）
  18.         Method loginMethod = userServiceClass.
  19.         getDeclaredMethod("login",String.class,String.class);
  20.         // 调用方法
  21.          /*
  22.         四要素：
  23.         loginMethod方法
  24.         obj对象
  25.         "admin","123" 实参
  26.         retValue 返回值
  27.          */
  28.         // invoke调用的意思
  29.          Object retValue = loginMethod.invoke(obj,"admin","123");
  30.          // obj这个对象invoke调用loginMethod方法，传参数
  31.         System.out.println(retValue);
  33.     }
  34. }

#

三：反射Constructor

思考：通过调用newInstance()方法的情况进行实例化，默认是调用无参的构造器：要求首先无参的构造器要有，其次无参的构造器的访问权限要够（例如public）；明显不够灵活。假设现在只有有参构造器，或者无参构造器的是private修饰的怎么办呢？

答：调用getDeclaredConstructor方法，参数相对于普通的方法调用而言不用指定方法名，因为构造方法的方法名是和类名相同的！传参就是调用有参构造器、不传参就是调用无参构造器，拿到构造器以后在调用newInstance方法进行对象的创建！对于private修饰的，还可以调用setAccessible(true)来打破封装！

1. 反编译Constructor

构造方法

  1. package com.bjpowernode.java.reflect;
  3. public class Vip {
  5.     int no;
  6.     String name;
  7.     String birth;
  8.     boolean sex;
  10.     public Vip() {
  11.     }
  13.     public Vip(int no) {
  14.         this.no = no;
  15.     }
  17.     public Vip(int no, String name) {
  18.         this.no = no;
  19.         this.name = name;
  20.     }
  22.     public Vip(int no, String name, String birth) {
  23.         this.no = no;
  24.         this.name = name;
  25.         this.birth = birth;
  26.     }
  28.     public Vip(int no, String name, String birth, boolean sex) {
  29.         this.no = no;
  30.         this.name = name;
  31.         this.birth = birth;
  32.         this.sex = sex;
  33.     }
  35.     // 重写一下toString
  36.     @Override
  37.     public String toString() {
  38.         return "Vip{" +
  39.                 "no=" + no +
  40.                 ", name='" + name + '\'' +
  41.                 ", birth='" + birth + '\'' +
  42.                 ", sex=" + sex +
  43.                 '}';
  44.     }
  45. }

反编译一个类的Constructor构造方法

  1. package com.bjpowernode.java.reflect;
  4. import java.lang.reflect.Constructor;
  5. import java.lang.reflect.Modifier;
  7. public class ReflectConstructorTest01 {
  8.     public static void main(String[] args) throws Exception{
  9.         StringBuilder s = new StringBuilder();
  11.         Class vipClass = Class.forName("com.bjpowernode.java.reflect.Vip");
  12.         //s.append("public class Vip {");
  13.         // 采用动态方式获取
  14.         s.append(Modifier.toString(vipClass.getModifiers())+" class "+vipClass.getSimpleName()+" {\n");
  16.         // 拼接构造方法
  17.         Constructor[] constructors = vipClass.getConstructors();
  18.         for (Constructor constructor :constructors){
  19.             s.append("\t");
  20.             // 追加修饰符
  21.             s.append(Modifier.toString(constructor.getModifiers()));
  22.             s.append(" ");
  23.             // 追加类名
  24.             s.append(vipClass.getSimpleName());
  25.             // 追加参数
  26.             s.append("(");
  27.             Class[] parameterTypes = constructor.getParameterTypes();
  28.             for (Class paramaterType: parameterTypes){
  29.                 s.append(paramaterType.getSimpleName());
  30.                 s.append(",");
  31.             }
  32.             // 删除最后元素下标位置上的字符
  33.             if(parameterTypes.length>0){
  34.                 s.deleteCharAt(s.length()-1);
  35.             }
  36.             s.append("){}\n");
  37.         }
  39.         s.append("}");
  41.         System.out.println(s);
  42.     }
  43. }
  45. /*
  46. public class Vip {
  47.     public Vip(int,String,String,boolean){}
  48.     public Vip(int,String,String){}
  49.     public Vip(int,String){}
  50.     public Vip(int){}
  51.     public Vip(){}
  52. }*/

2. 反射机制调用构造方法（了解）

通过反射机制调用构造方法实例化java对象。（这个不是重点）

  1. package com.bjpowernode.java.reflect;
  3. import java.lang.reflect.Constructor;
  5. // 比上一个例子重要
  6. public class ReflectConstructorTest02 {
  7.     public static void main(String[] args) throws Exception {
  8.         //1. 不使用反射机制怎么创建对象
  9.         Vip v1 = new Vip();
  10.         Vip v2 = new Vip(110,"zhangsan","2022-10-11",true);
  12.         //2. 使用反射机制
  13.         Class c = Class.forName("com.bjpowernode.java.reflect.Vip");
  14.         // 调用无参构造方法
  15.         Object obj = c.newInstance();
  16.         System.out.println(obj);
  18.         // 调用有参构造方法（ 区分构造方法只需要形参）
  19.         // 第一步：先获取到这个有参数的构造方法
  20.         Constructor con = c.getDeclaredConstructor(int.class,String.class,String.class,boolean.class);
  21.         // 第二步：调用构造方法new对象、
  22.         Object newobj = con.newInstance(220,"lisi","2022-10-10",true);
  23.         System.out.println(newobj);
  25.         // 调用无参构造方法，也可以先拿到构造方法
  26.         Constructor con1 = c.getDeclaredConstructor(); // 什么都不传
  27.         System.out.println(con1.newInstance());
  29.     }
  30. }

3. 补充：获取父类和父类的接口（重点）

一个类，怎么获取这个类的父类和已经实现了哪些接口(或者说是父类所拥有的接口)？

（1）调用getSuperclass()方法，可以获取当前类的父类。

（2）调用getInterfaces()方法，返回的是一个Class数组；遍历这个数组的每个对象调用getName()方法，可以获取当前类实现的所有接口或者说是当前类的父类所拥有的的所有的接口。

  1. package com.bjpowernode.java.reflect;
  2. /*
  3. 重点：给你一个类，怎么获取这个类的父类，已经实现了哪些接口？
  4.  */
  5. public class ReflectTest09 {
  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 inter : interfaces){
  17.             System.out.println(inter.getName());
  18.         }
  19.     }
  20. }

#

#

发表评论

表情：
评论列表 （有 0 条评论，119人围观）

还没有评论，来说两句吧...

相关阅读

    相关 【JavaSE】反射

    一、概念 反射是在运行期间，动态获取对象的属性和方法 二、相关的类 在Java的反射里主要有以下几个类：Class类，这是反射的起源，反射必须要先获取Class对

    ╰+攻爆jí腚メ╰+攻爆jí腚メ/ 0 赞/ 201 阅读

    相关 javaSE--7反射机制

    一、反射机制 1.反射机制的作用 通过java语言中的反射机制可以操作字节码文件（类似于黑客，可以读和写字节码文件） 可以操作代码片段（class文件） 反射机

    末蓝、末蓝、/ 0 赞/ 228 阅读

    相关 JavaSE 反射机制

    反射机制是什么 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调

    矫情吗；*矫情吗；*/ 0 赞/ 324 阅读

    相关 javaSE_反射

    反射就是可以通过程序动态的去修改jvm虚拟机已经加载好的方法区里面的属性、成员变量。 通过反射获取类： Class clz = Class.forName("com.gar

    以你之姓@以你之姓@/ 0 赞/ 208 阅读