Java introduit l'obtention d'informations de classe par réflexion

Recommandations d'apprentissage gratuites : Tutoriel de base Java

Répertoire

• 1. Obtenir le champ
• 2. Décompiler le champ
• 3. Accéder aux propriétés de l'objet via le mécanisme de réflexion
• 4. . Paramètres de longueur variable
• 5. Méthode de réflexion (comprendre)
• 6. Décompiler (comprendre)
• 7. Méthode d'appel du mécanisme de réflexion
• 8. Réflexion Constructeur
• 9. Le mécanisme de réflexion appelle le constructeur
• 10. Obtenir la classe parent et l'interface parent

Dans la section précédente, nous avons présenté le mécanisme de réflexion Réflexion détaillée. mécanisme, dans cette section, nous présenterons comment obtenir des attributs de classe, des méthodes et d'autres informations par réflexion.

1. Obtenir Field

public class ReflectTest03 {
    public static void main(String[] args) throws Exception{
        //1.获取整个类
        Class studentClass=Class.forName("cn.yujie.bean.Student");
        String className=studentClass.getName();
        System.out.println(className);
        System.out.println(studentClass.getSimpleName());

        //获取类中的所有public的Field
        Field[] fields=studentClass.getFields();
        System.out.println(fields.length);      //测试数组中只有1个元素
        //测试这个field
        Field f=fields[0];
        //取出field的它的名字
        String fieldName=f.getName();
        System.out.println(fieldName);

        //获取所有的Field
        //获取所有的Field
        Field[] fs=studentClass.getDeclaredFields();
        System.out.println(fs.length);
        System.out.println("-----------------");
        //遍历
        for(Field field :fs){
            //获取属性的修饰符列表
            //返回的修饰符是一个数字，每个数字是修饰符的代号
            int i=field.getModifiers();
            //可以将这个代号数字转换成字符串
            String ModifierString = Modifier.toString(i);
            System.out.print(ModifierString+" ");
            //获取属性的类型
            Class fieldType=field.getType();
            String fName=fieldType.getSimpleName();
            System.out.print(fName+" ");
            //获取属性的名字
            System.out.println(field.getName()+" ");
            System.out.println();
        }
    }}

2. Décompiler Field

Décompiler les attributs d'une classe via le mécanisme de réflexion Field

public class ReflectTest05 {
    public static void main(String[] args) throws Exception{
        //创建这个是为了拼接字符串
        StringBuilder s=new StringBuilder();
        Class studentClass=Class.forName("cn.yujie.bean.Student");
        s.append(Modifier.toString(studentClass.getModifiers())+" class "+studentClass.getSimpleName()+"{");
        Field[] fields=studentClass.getDeclaredFields();
        s.append(";\n");
        for(Field field:fields){
            s.append("\t");
            s.append(Modifier.toString(field.getModifiers()));
            s.append(" ");
            s.append(field.getType().getSimpleName());
            s.append(" ");
            s.append(field.getName());
            s.append(";\n");
        }
        s.append("}");
        System.out.println(s);
    }}

3. Accéder aux propriétés de l'objet via le mécanisme de réflexion

Doit maîtriser :
Comment utiliser le mécanisme de réflexion Accès les attributs d'un objet
Attribuer une valeur à l'ensemble d'attributs
Obtenir la valeur de l'attribut get

public class ReflectTest07 {
    public static void main(String[] args) throws Exception{

        Class studentClass=Class.forName("cn.yujie.bean.Student");
        //使用反射机制，怎么取访问一个对象的属性
        Object obj=studentClass.newInstance();  //obj就是student对象(底层调用无参数构造方法)
        //获取no属性(根据属性的名称获取Field)
        Field noFiled=studentClass.getDeclaredField("no");
        //给obj对象(Student对象)的no属性赋值
        //s.no=111;         //给s对象的no属性赋值111，三要素，对象，属性和值
        //虽然使用了反射机制，但是三要素还是缺一不可
        //注意，反射机制让代码复杂了，但是为了一个灵活，这也是值得的。
        noFiled.set(obj,222);           //给obj对象的no属性赋值222
        //读取属性的值
        //两个要素：获取obj对象no属性的值
        System.out.println(noFiled.get(obj));
        //可以访问私有属性吗
        Field nameField=studentClass.getDeclaredField("name");
        //打破封装（反射机制的缺点：打破封装，可能会给不法分子留下机会）
        nameField.setAccessible(true);
        //给name属性赋值
        nameField.set(obj,"jackson");
        //获取name属性的值
        System.out.println(nameField.get(obj));

    }}

4. Paramètres de longueur variable

Paramètres de longueur variable
int... args Il s'agit du paramètre de longueur variable
La syntaxe est : tapez... (remarque : il doit y avoir 3 points)

• 1. Le nombre de paramètres requis pour les paramètres de longueur variable est 0-n
• 2. liste de paramètres et sont variables Il ne doit y avoir qu'un seul paramètre de longueur
• 3. La longueur variable peut être considérée comme un tableau

public class ArgumentsTest {
    public static void main(String[] args) {
      m();
      m(10);
      m(20,40);
      //m("abc");编译错误
      m3("ab","cd","def","de9");
      String [] strs={"a","b","c"};
      m3(strs);
    }
    public static void m(int... args){

    }
    //必须在最后一个，且只有1个//    public static void m2(String... args1,int...args2){////    }
    public static void m3(String ...args){
        //可以将可变长度参数当成一个数组来看
        for(int i=0;i<args.length><p><strong>5. 🎜></strong></p>
<pre class="brush:php;toolbar:false">public class ReflectTest08 {
    public static void main(String[] args) throws Exception{
        //获取类了
        Class userServiceClass = Class.forName("cn.yujie.service.UserService");
        //获取所有的Method(包括私有的)
        Method[] methods=userServiceClass.getDeclaredMethods();
        System.out.println(methods.length);         //2
        //遍历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());
            }
        }

    }}

6. Décompiler (comprendre)

public class ReflectTest09 {
    public static void main(String[] args) throws Exception{
        StringBuilder s=new StringBuilder();
        Class userServiceClass = Class.forName("cn.yujie.service.UserService");
        s.append("public class UserService{ ");
        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(",");
            }
            s.append("){}\n");
        }
        //删除指定下标位置上的字符
        s.deleteCharAt(s.length()-1);
        s.append("}");
        System.out.println(s);
    }}

7. Méthode d'appel du mécanisme de réflexion

Point clé : Vous doit maîtriser comment appeler une méthode via la méthode du mécanisme de réflexion.

Le mécanisme de réflexion rend le code plus polyvalent. Après avoir modifié le fichier de configuration à l'avenir, les objets créés seront différents et les méthodes appelées seront différentes, mais le code Java n'a en aucun cas besoin d'être modifié. c'est le charme de la réflexion .

public class ReflectTest10 {
    public static void main(String[] args) throws Exception{
        //通过反射机制调用方法
        Class userServiceClass = Class.forName("cn.yujie.service.UserService");
        //创建对象
        Object obj=userServiceClass.newInstance();
        //java中有重载，java中通过方法名和形参来区分方法
        Method loginMethod=userServiceClass.getDeclaredMethod("login",String.class,String.class);
        //调用方法
        //调用方法有几个要素
        //要素1：对象，要素2：方法名，要素3：参数列表，要素4：返回值
        //反射机制中最重要的一个方法：必须记住
        //四要素
        /*
        loginMethod方法，obj对象
        admin,123是参数列表，retValue是返回值
        * */
        Object retValue=loginMethod.invoke(obj,"admin","123");
    }}

8. Constructeur de réflexion

public class ReflectTest11 {
    public static void main(String[] args) throws Exception{
        StringBuilder s=new StringBuilder();
        Class vipClass=Class.forName("cn.yujie.bean.Vip");
        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);
    }}

9. Le mécanisme de réflexion appelle le constructeur

public class ReflectTest12 {
    public static void main(String[] args) throws Exception{
        //使用反射机制怎么创建对象
        Class vipClass=Class.forName("cn.yujie.bean.Vip");
        //调用无参构造方法
        Object obj= vipClass.newInstance();
        //调用有参数构造方法
        //第一步：先获取到有参数构造方法
        Constructor con=vipClass.getDeclaredConstructor(int.class,String.class,String.class,boolean.class);
        //第二步：调用构造方法new对象
        Object newObj=con.newInstance(110,"jackson","1999-10-11",true);
        System.out.println(newObj);
    }}

10. Obtenez la classe parent et l'interface parent

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.getSimpleName());
        //获取String类实现的所有接口
        Class[] interfaces=stringClass.getInterfaces();
        for(Class in:interfaces){
            System.out.println(in.getName());
        }
    }}

Recommandations d'apprentissage gratuites associées : bases de Java

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!