精华内容
下载资源
问答
  • Java基础——Modifier类

    2019-09-29 21:44:09
    转自:https://www.cnblogs.com/baiqiantao/p/7478523.html 反射 Reflect Modifier 修饰符工具 在查看反射相关的Class、Field 、Constructor 等时,看到他们都有这样一个方法:getModifiers()...

    转自:https://www.cnblogs.com/baiqiantao/p/7478523.html   反射 Reflect Modifier 修饰符工具类

     

    在查看反射相关的Class、Field 、Constructor 等类时,看到他们都有这样一个方法:getModifiers():返回此类或接口以整数编码的 Java 语言修饰符。如需要知道返回的值所代表的意思,则需要用到 java.lang.reflect.Modifier 这个类,这个类提供了 static 方法和常量,可以对类和成员访问修饰符进行解码。

     

    既然是位于 java.lang.reflect 下,那说明一般是在动态加载过程中、使用java反射对某些类进行过滤时会用到,一般开发并不是很常用。但是对于写框架,个人还是觉得可以用到的。

     

    Modifier 修饰符工具类

    public class java.lang.reflect.Modifier extends Object

    JDK中的介绍:

    Modifier 类提供了 static 方法和常量,对类和成员访问修饰符进行解码。修饰符集被表示为整数,用不同的位位置 (bit position) 表示不同的修饰符。表示修饰符的常量值取自于 The JavaTM Virtual Machine Specification, Second edition 的表 4.14.44.5 和 4.7

     

    访问修饰符列表

    • public static final int PUBLIC  = 0x00000001;
    • public static final int PRIVATE  = 0x00000002;
    • public static final int PROTECTED  = 0x00000004;
    • public static final int STATIC  = 0x00000008;
    • public static final int FINAL  = 0x00000010;
    • public static final int SYNCHRONIZED  = 0x00000020;        同步
    • public static final int VOLATILE  = 0x00000040;        用volatile修饰的变量,线程在每次使用变量的时候,都会读取变量修改后的最的值。
    • public static final int TRANSIENT  = 0x00000080;        用transient关键字标记的成员变量不参与序列化过程。
    • public static final int NATIVE  = 0x00000100;
    • public static final int INTERFACE  = 0x00000200;
    • public static final int ABSTRACT  = 0x00000400;
    • public static final int STRICT  = 0x00000800;        即strictfp(strict float point 精确浮点),此关键字可应用于类、接口或方法。

     

    解码方法

    以上所有的修饰符都有对应的、方法声明为【public static boolean is***(int mod)】的解码方法,且方法的实现也都是类似的,比如:

    public static boolean isPublic(int mod) {
    return (mod & PUBLIC) != 0;
    }

     

    新增的方法

    1.7及1.8中新增了几个API,目的是对CLASS、INTERFACE、CONSTRUCTOR、METHOD、FIELD、PARAMETER等类型的对象可以使用的所有修饰符。

    private static final int CLASS_MODIFIERS =
    Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
    Modifier.ABSTRACT | Modifier.STATIC | Modifier.FINAL |
    Modifier.STRICT;
    public static int classModifiers() {
    return CLASS_MODIFIERS;
    }
    private static final int INTERFACE_MODIFIERS =
    Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
    Modifier.ABSTRACT | Modifier.STATIC | Modifier.STRICT;
    public static int interfaceModifiers() {
    return INTERFACE_MODIFIERS;
    }
    private static final int CONSTRUCTOR_MODIFIERS =
    Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE;
    public static int constructorModifiers() {
    return CONSTRUCTOR_MODIFIERS;
    }
    private static final int METHOD_MODIFIERS =
    Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
    Modifier.ABSTRACT | Modifier.STATIC | Modifier.FINAL |
    Modifier.SYNCHRONIZED | Modifier.NATIVE | Modifier.STRICT;
    public static int methodModifiers() {
    return METHOD_MODIFIERS;
    }
    private static final int FIELD_MODIFIERS =
    Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE |
    Modifier.STATIC | Modifier.FINAL | Modifier.TRANSIENT |
    Modifier.VOLATILE;
    public static int fieldModifiers() {
    return FIELD_MODIFIERS;
    }
    private static final int PARAMETER_MODIFIERS =
    Modifier.FINAL;
    public static int parameterModifiers() {
    return PARAMETER_MODIFIERS;
    }

     

    toString 方法的实现

    public static String toString(int mod) {
    StringBuilder sb = new StringBuilder();
    int len;
    if ((mod & PUBLIC) != 0) sb.append("public ");
    if ((mod & PROTECTED) != 0) sb.append("protected ");
    if ((mod & PRIVATE) != 0) sb.append("private ");
    /* Canonical典范、规范 order */
    if ((mod & ABSTRACT) != 0) sb.append("abstract ");
    if ((mod & STATIC) != 0) sb.append("static ");
    if ((mod & FINAL) != 0) sb.append("final ");
    if ((mod & TRANSIENT) != 0) sb.append("transient ");
    if ((mod & VOLATILE) != 0) sb.append("volatile ");
    if ((mod & SYNCHRONIZED) != 0) sb.append("synchronized ");
    if ((mod & NATIVE) != 0) sb.append("native ");
    if ((mod & STRICT) != 0) sb.append("strictfp ");
    if ((mod & INTERFACE) != 0) sb.append("interface ");
    /* trim trailing space */
    if ((len = sb.length()) > 0) return sb.toString().substring(0, len-1);
    return "";
    }

     

    示例1:解码mod演示

    public class Test {
    private static final transient int temp = 1;
    public static void main(String[] args) throws Exception {
    testModifier(Test.class.getDeclaredField("temp").getModifiers());//154。private static final transient
    testModifier(Test.class.getMethod("main", String[].class).getModifiers());//9。public static
    }
    public static void testModifier(int mod) {
    System.out.println("----------------------【mod=" + mod + "】----------------------");
    System.out.println("【toString】" + Modifier.toString(mod));
    System.out.println("【isPublic】" + Modifier.isPublic(mod));
    System.out.println("【isPrivate】" + Modifier.isPrivate(mod));
    System.out.println("【isProtected】" + Modifier.isProtected(mod));
    System.out.println("【isStatic】" + Modifier.isStatic(mod));
    System.out.println("【isFinal】" + Modifier.isFinal(mod));
    System.out.println("【isSynchronized】" + Modifier.isSynchronized(mod));
    System.out.println("【isVolatile】" + Modifier.isVolatile(mod));
    System.out.println("【isTransient】" + Modifier.isTransient(mod));
    System.out.println("【isNative】" + Modifier.isNative(mod));
    System.out.println("【isInterface】" + Modifier.isInterface(mod));
    System.out.println("【isAbstract】" + Modifier.isAbstract(mod));
    System.out.println("【isStrict】" + Modifier.isStrict(mod));
    }
    }

     

    示例2:不同类型元素可使用的修饰符

    System.out.println(Modifier.toString(Modifier.classModifiers()));//public protected private abstract static final strictfp
    System.out.println(Modifier.toString(Modifier.interfaceModifiers()));//public protected private abstract static strictfp
    System.out.println(Modifier.toString(Modifier.constructorModifiers()));//public protected private
    System.out.println(Modifier.toString(Modifier.methodModifiers()));//public protected private abstract static final synchronized native strictfp
    System.out.println(Modifier.toString(Modifier.fieldModifiers()));//public protected private static final transient volatile
    System.out.println(Modifier.toString(Modifier.parameterModifiers()));//final

    转载于:https://www.cnblogs.com/jpfss/p/11607595.html

    展开全文
  • 在java核心技术中的定义是:反射是能够分析能力的程序。 二.我们可以用反射来干什么? 1.分析的能力 2.查看对象 3.实现通用的数组操作代码 4.利用Method方法 我们要注意的是使用反射的主要人员是工具的构造者,...

    总结自《Java核心技术卷Ⅰ》

    一.什么是反射?

    在java核心技术中的定义是:反射是能够分析类能力的程序

    Java反射的内容主要在java.lang.reflect包中。

    二.我们可以用反射来干什么?(4点)

    1.在程序运行时分析类的能力:查看类方法,属性

    2.在程序运行时查看对象和操作对象:
    1)基于反射自由创建对象
    2)构建出无法直接访问的类
    3)set或者get到无法访问的成员变量
    4)调用不可访问的方法

    3.实现通用的数组操作代码,实现泛型数组操作代码

    4.利用Method对象实现类似函数指针的功能

    我们要注意的是使用反射的主要人员是工具的构造者,而不是应用程序员。这意味着反射对于工具级别的开发人员是非常重要的。

    三.具体的学习

    对上面的定义总感觉有些云里雾里的感觉,似懂非懂,下面我们以实例出发来理解反射。

    1.在运行时分析类的能力(Class类)

    1).Class类
    在程序运行期间,java运行时系统始终为所有的对象保存了一个被称为运行时的类型标识信息,这个信息跟踪着每个对象所属的类,虚拟机利用运行时类型标识信息选择相应的方法执行。

    然而,我们可以通过专门的java类来访问这些信息,Class类就是其中之一。(Class保存这些信息)

    Object类中的getClass()方法将会返回一个Class类型的实例。

    1)如何得到Class实例(三种方式)

    有以下方式:

    方式一:调用Object种的getClass()方法
      Employee e=new Employee();
      Class cl=e.getClass();//e为目标对象,getClass方法在object中存在
      System.out.println(cl.getName());//打印的是 Employee,如果类Employee在一个包中,包名也算在其中
                                        //就是Bao.Employee
                                        
    方式二:调用不可变类Class中的静态方法forName()
    try{
    String className="java.util.Random";
    Class cl=Class.forName(className);//这里的className的内容必须类名或接口名才有效
     System.out.println(c1.getName());//打印的为java.util.Random
     }catch(Exception e)
       {
           e.printStackTrace();
       }
    
    方式三:直接Class cl=T.class;
    Class cl=Random.class;
    System.out.println(cl.getName());//打印的为java.util.Random
    cl.newInstance();//返回这个类的一个新实例,除了new,我们还可以使用这个方法来获得实例,我们可以通过newInstance()来产生对象而不是通过new
    

    2)虚拟机为每个类型管理一个唯一的Class对象,因此,我们可以利用==运算符实现两个类对象的比较。

    例如:e.getClass()==Employee.class 的结果,如果e是Employee实例,这个测试将通过,如果e是Employee某个子类的实例,则不通过,这与 instanceof 不同。

    反射库提供了一个非常丰富且精心设计的工具集,以便能够动态操纵Java代码的程序。

    2.利用反射来分析类能力

    实现这一功能我们还需要用到java.lang.reflect包中的一些类:
    Field,Method,Constructor,Modifier四个类

    下面介绍这些类中的一些要用到的方法(先了解即可):

    1)Class类中的方法

    Field[] getFields();
    返回一个包含Field对象的数组,这些对象记录了这个类或其父类的公有域。

    Field[] getDeclaredFields();
    返回包含Field对象的数组,这些对象记录了这个类的全部域。

    Method[] getMethods();
    返回包含Method对象的数组,其包含所有的公有方法,包括父类的。

    Method[] getDeclareMethods();
    返回包含Method对象的数组,其包含所有的方法,但不包括包括父类的。

    Constructor[] getConstructors();
    返回包含Constructor对象的数组,其中包含了Class对象所描述的所有公有构造方法。

    Constructor[] getDeclaredConstructors();
    返回包含Constructor对象的数组,其中包含了Class对象所描述的所有构造方法。

    2)Field,Method,Constructor类

    在这里插入图片描述

    3)Modifier类

    在这里插入图片描述

    例子

    下面是用上面的类来写的一个反射(通过查阅相关的API来阅读):

    package day01;
    
    import java.util.*;
    import java.lang.reflect.*;
    
    public class ReflectionTest
    {
       public static void main(String[] args)
       {
          String name;//用于存储类名
          if (args.length > 0) name = args[0];
          else
          {
             Scanner in = new Scanner(System.in);
             System.out.println("Enter class name (e.g:java.util.Date): ");
             name = in.next();
          }
          try
          {
             Class cl = Class.forName(name);//得到此类的Class实例
             Class supercl = cl.getSuperclass();//得到其父类的Class对象
             
             /*返回cl修饰符的字符串表示
              int getModifiers();返回一个整数,描述调用对象的修饰符
              Modifier.toString(int modifiers);返回此修饰符的字符串表示
             */
             String modifiers = Modifier.toString(cl.getModifiers());
    
             //打印出这个类的声明
             if (modifiers.length() > 0) System.out.print(modifiers + " ");
             System.out.print("class " + name);
             //打印它继承的父类
             if (supercl != null && supercl != Object.class) System.out.print(" extends "
                   + supercl.getName());
            //打印花括号
             System.out.print("\n{\n");
             //打印cl的构造方法
             printConstructors(cl);
             System.out.println();
             //打印cl的其他方法
             printMethods(cl);
             System.out.println();
             //cl中的所有域
             printFields(cl);
             System.out.println("}");
          }
          catch (ClassNotFoundException e)
          {
             e.printStackTrace();
          }
          System.exit(0);
       }
    
    
       /*
        打印所有构造方法
       */
       public static void printConstructors(Class cl)
       {
          //得到包含cl中的全部构造器的一个Constructor对象数组
          Constructor[] constructors = cl.getDeclaredConstructors();
    
          for (Constructor c : constructors)
          {
             String name = c.getName();
             System.out.print("   ");
             String modifiers = Modifier.toString(c.getModifiers());
             if (modifiers.length() > 0) System.out.print(modifiers + " ");         
             System.out.print(name + "(");
    
             // Class[] getParameterTypes(); 返回一个Class对象数组,其中各个对象表示参数的类型
             Class[] paramTypes = c.getParameterTypes();
             for (int j = 0; j < paramTypes.length; j++)
             {
                if (j > 0) System.out.print(", ");
                System.out.print(paramTypes[j].getName());
             }
             System.out.println(");");
          }
       }
    
       /*
        打印所有方法
       */
       public static void printMethods(Class cl)
       {
          //得到这个类中的全部方法数组
          Method[] methods = cl.getDeclaredMethods();
    
          for (Method m : methods)
          {
             Class retType = m.getReturnType();//返回一个用于表示返回类型的Class对象
             String name = m.getName();
    
             System.out.print("   ");
             // 打印修饰符,返回类型和方法名
             String modifiers = Modifier.toString(m.getModifiers());
             if (modifiers.length() > 0) System.out.print(modifiers + " ");         
             System.out.print(retType.getName() + " " + name + "(");
    
             // 打印参数部分
             Class[] paramTypes = m.getParameterTypes();
             for (int j = 0; j < paramTypes.length; j++)
             {
                if (j > 0) System.out.print(", ");
                System.out.print(paramTypes[j].getName());
             }
             System.out.println(");");
          }
       }
    
      /*
       打印此类的所有域
      */
       public static void printFields(Class cl)
       {
          Field[] fields = cl.getDeclaredFields();//返回包含Field对象的数组,这些对象对应这个类的全部字段
    
          for (Field f : fields)
          {
             Class type = f.getType();
             String name = f.getName();
             System.out.print("   ");
             String modifiers = Modifier.toString(f.getModifiers());
             if (modifiers.length() > 0) System.out.print(modifiers + " ");         
             System.out.println(type.getName() + " " + name + ";");
          }
       }
    }
    

    结果:

    在这里插入图片描述

    展开全文
  • 在查看反射相关的Class、Field...如需要知道返回的值所代表的意思,则需要用到 java.lang.reflect.Modifier 这个,这个提供了 static 方法和常量,可以对和成员访问修饰符进行解码。既然是位于 java.lang.refl...
    在查看反射相关的Class、Field 、Constructor 等类时,看到他们都有这样一个方法:getModifiers():返回此类或接口以整数编码的 Java 语言修饰符。 如需要知道返回的值所代表的意思,则需要用到 java.lang.reflect.Modifier 这个类,这个类提供了 static 方法和常量,可以对类和成员访问修饰符进行解码。

    既然是位于 java.lang.reflect 下,那说明一般是在动态加载过程中、使用java反射对某些类进行过滤时会用到,一般开发并不是很常用。但是对于写框架,个人还是觉得可以用到的。

    Modifier 修饰符工具类

    public class java.lang.reflect.Modifier extends Object
    JDK中的介绍:
    Modifier 类提供了  static  方法和常量,对类和成员访问修饰符进行解码。修饰符集被表示为整数,用不同的位位置 (bit position) 表示不同的修饰符。表示修饰符的常量值取自于  The JavaTM Virtual Machine Specification, Second edition  的表  4.1 4.4 4.5    4.7

    访问修饰符列表

    • public static final int PUBLIC  = 0x00000001;
    • public static final int PRIVATE  = 0x00000002;
    • public static final int PROTECTED  = 0x00000004;
    • public static final int STATIC  = 0x00000008;
    • public static final int FINAL  = 0x00000010;
    • public static final int SYNCHRONIZED  = 0x00000020;        同步
    • public static final int VOLATILE  = 0x00000040;        用volatile修饰的变量,线程在每次使用变量的时候,都会读取变量修改后的最的值。
    • public static final int TRANSIENT  = 0x00000080;        用transient关键字标记的成员变量不参与序列化过程。
    • public static final int NATIVE  = 0x00000100;
    • public static final int INTERFACE  = 0x00000200;
    • public static final int ABSTRACT  = 0x00000400;
    • public static final int STRICT  = 0x00000800;        即strictfp(strict float point 精确浮点),此关键字可应用于类、接口或方法。

    解码方法

    以上所有的修饰符都有对应的、方法声明为【public static boolean is***(int mod)】的解码方法,且方法的实现也都是类似的,比如:
    public static boolean isPublic(int mod) {
        return (mod & PUBLIC) != 0;
    }

    新增的方法

    1.7及1.8中新增了几个API,目的是对CLASS、INTERFACE、CONSTRUCTOR、METHOD、 FIELD、PARAMETER等类型的对象可以使用的所有修饰符。
    private static final int CLASS_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
        Modifier.STRICT;
    public static int classModifiers() {
        return CLASS_MODIFIERS;
    }
    
    private static final int INTERFACE_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.STRICT;
    public static int interfaceModifiers() {
        return INTERFACE_MODIFIERS;
    }
    
    private static final int CONSTRUCTOR_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE;
    public static int constructorModifiers() {
        return CONSTRUCTOR_MODIFIERS;
    }
    
    private static final int METHOD_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
        Modifier.SYNCHRONIZED   | Modifier.NATIVE       | Modifier.STRICT;
    public static int methodModifiers() {
        return METHOD_MODIFIERS;
    }
    
    private static final int FIELD_MODIFIERS =
        Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
        Modifier.STATIC         | Modifier.FINAL        | Modifier.TRANSIENT |
        Modifier.VOLATILE;
    public static int fieldModifiers() {
        return FIELD_MODIFIERS;
    }
    
    private static final int PARAMETER_MODIFIERS =
        Modifier.FINAL;
    public static int parameterModifiers() {
        return PARAMETER_MODIFIERS;
    }

    toString 方法的实现

    public static String toString(int mod) {
        StringBuilder sb = new StringBuilder();
        int len;
    
        if ((mod & PUBLIC) != 0)        sb.append("public ");
        if ((mod & PROTECTED) != 0)     sb.append("protected ");
        if ((mod & PRIVATE) != 0)       sb.append("private ");
    
        /* Canonical典范、规范 order */
        if ((mod & ABSTRACT) != 0)      sb.append("abstract ");
        if ((mod & STATIC) != 0)        sb.append("static ");
        if ((mod & FINAL) != 0)         sb.append("final ");
        if ((mod & TRANSIENT) != 0)     sb.append("transient ");
        if ((mod & VOLATILE) != 0)      sb.append("volatile ");
        if ((mod & SYNCHRONIZED) != 0)  sb.append("synchronized ");
        if ((mod & NATIVE) != 0)        sb.append("native ");
        if ((mod & STRICT) != 0)        sb.append("strictfp ");
        if ((mod & INTERFACE) != 0)     sb.append("interface ");
    
        /* trim trailing space */
        if ((len = sb.length()) > 0)  return sb.toString().substring(0, len-1);
        return "";
    }

    示例1:解码mod演示

    public class Test {
    	private static final transient int temp = 1;
    
    	public static void main(String[] args) throws Exception {
    		testModifier(Test.class.getDeclaredField("temp").getModifiers());//154。private static final transient
    		testModifier(Test.class.getMethod("main", String[].class).getModifiers());//9。public static
    	}
    
    	public static void testModifier(int mod) {
    		System.out.println("----------------------【mod=" + mod + "】----------------------");
    		System.out.println("【toString】" + Modifier.toString(mod));
    		System.out.println("【isPublic】" + Modifier.isPublic(mod));
    		System.out.println("【isPrivate】" + Modifier.isPrivate(mod));
    		System.out.println("【isProtected】" + Modifier.isProtected(mod));
    		System.out.println("【isStatic】" + Modifier.isStatic(mod));
    		System.out.println("【isFinal】" + Modifier.isFinal(mod));
    		System.out.println("【isSynchronized】" + Modifier.isSynchronized(mod));
    		System.out.println("【isVolatile】" + Modifier.isVolatile(mod));
    		System.out.println("【isTransient】" + Modifier.isTransient(mod));
    		System.out.println("【isNative】" + Modifier.isNative(mod));
    		System.out.println("【isInterface】" + Modifier.isInterface(mod));
    		System.out.println("【isAbstract】" + Modifier.isAbstract(mod));
    		System.out.println("【isStrict】" + Modifier.isStrict(mod));
    	}
    }

    示例2:不同类型元素可使用的修饰符

    System.out.println(Modifier.toString(Modifier.classModifiers()));//public protected private abstract static final strictfp
    System.out.println(Modifier.toString(Modifier.interfaceModifiers()));//public protected private abstract static strictfp
    System.out.println(Modifier.toString(Modifier.constructorModifiers()));//public protected private
    System.out.println(Modifier.toString(Modifier.methodModifiers()));//public protected private abstract static final synchronized native strictfp
    System.out.println(Modifier.toString(Modifier.fieldModifiers()));//public protected private static final transient volatile
    System.out.println(Modifier.toString(Modifier.parameterModifiers()));//final
    2017-9-5




    展开全文
  • 反射修饰符 Modifier

    2019-06-15 23:43:29
    java中反射获取方法的修饰符 代码演示: ... import java.lang.reflect.Field;...import java.lang.reflect.Modifier; public class LFrog { public String name0; public static String name...

    Modifier 修饰符工具类

    public class java.lang.reflect.Modifier extends Object

    int java.lang.reflect.Field.getModifiers()
    以整数形式返回此 Method 对象所表示方法的 Java 语言修饰符

    boolean java.lang.reflect.Modifier.isPublic(int mod)
    如果整数参数包括 public 修饰符,则返回 true,否则返回 false。其他方法类似

    方法的修饰符获取与属性类似

    JDK中的介绍:

    Modifier 类提供了 static 方法和常量,对类和成员访问修饰符进行解码。修饰符集被表示为整数,用不同的位位置 (bit position) 表示不同的修饰符。表示修饰符的常量值取自于 The JavaTM Virtual Machine Specification, Second edition 的表 4.1、4.4、4.5 和 4.7。

    解码方法

    以上所有的修饰符都有对应的、方法声明为【public static boolean is***(int mod)】的解码方法,且方法的实现也都是类似的,比如:

    public static boolean isPublic(int mod) {
    return (mod & PUBLIC) != 0;
    }

    java中反射获取方法的修饰符

    代码演示:

    package com.caoguangli.reflect;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    public class LFrog {
    
    	    public String name0;
    	    public static String name1;
    	    public static final String name2 = "name";
    	    
    	    public static void main(String[] args) throws NoSuchFieldException, SecurityException {
    	        LFrog frog = new LFrog();
    	        Class<? extends LFrog> frogClass = frog.getClass();
    	        Field name0 = frogClass.getField("name0");
    	        Field name1 = frogClass.getField("name1");
    	        Field name2 = frogClass.getField("name2");
    	        //以整数形式返回此Field 对象所表示方法的 Java 语言修饰符
    	        int m0 = name0.getModifiers();// 1
    	        int m1 = name1.getModifiers();// 9(1+8)
    	        int m2 = name2.getModifiers();// 25(1+8+16)
    	        //0 表示没有此修饰符
    	        System.out.println("m2 isPublic: " + (m2&1));// 1
    	        System.out.println("m2 isPrivate: " + (m2&2));// 0
    	        System.out.println("m2 isStatic: " + (m2&8));// 8
    	        System.out.println("m2 isFinal: " + (m2&16));// 16
    	        //false 表示没有被此修饰符修饰
    	        System.out.println("m2 isPublic: " + (Modifier.isPublic(m2)));// true
    	        System.out.println("m2 isPrivate: " + (Modifier.isPrivate(m2)));// false
    	        System.out.println("m2 isStatic: " + (Modifier.isStatic(m2)));// true
    	        System.out.println("m2 isFinal: " + (Modifier.isFinal(m2)));// true
    	    }
    }
    
    

    运行结果:

    在这里插入图片描述

    反射怎么知道成员是被哪些修饰符所修饰的呢?

    Java针对类、成员变量、方法,有很多修饰符,例如public、private、static、final、synchronized、abstract等,这些修饰符用来控制访问权限或其他特性。

    本文就用成员变量(Field)来举例说明,类以及方法的修饰符获取与成员变量是一样的。

    先看一个类(通过反射,可以拿到这四个变量):

    package com.caoguangli.reflect;
    
    import java.lang.reflect.Field;
    
    public class MyTest {
    	
    	public int a;
    	 
        public static int b;
     
        public static final int c = 0;
     
        private int d;
    
    
    public static void main(String[] args) {
     
           Class<?> clazz = MyTest.class;
     
           Field[] fields = clazz.getDeclaredFields();//获取这个类所有的成员变量
     
           for(Field field : fields) {
     
          System.out.println(field.getName());
               
     
           }
        }
    }
    
    

    运行结果:
    在这里插入图片描述

    现在,我想知道每个变量的带有哪些修饰符,或者是不是包含某个修饰符。

    先看下Member接口:Member表示一个类中的成员,包括成员变量、方法、构造方法三种实现,上面用到的Field就是Member的一种。

    Java文档:

    java.lang.reflect

    接口 Member

    所有已知实现类:

    Constructor(构造方法), Field(成员变量), Method(方法)
    Member接口有个方法:
    int getModifiers()

    作为整数返回由此 Member所表示的成员或构造方法的 Java语言修饰符。

    同时再看java.lang.Class类中也有同样的一个方法:

    int getModifiers()

    返回此类或接口以整数编码的 Java语言修饰符。

    这个方法就是返回一个int型的返回值,代表类、成员变量、方法的修饰符。

    代码演示:

    package com.caoguangli.reflect;
    
    import java.lang.reflect.Field;
    
    public class MyTest {
    	
    	public int a;
    	 
        public static int b;
     
        public static final int c = 0;
     
        private int d;
    
    
    public static void main(String[] args) {
     
           Class<?> clazz = MyTest.class;
     
           Field[] fields = clazz.getDeclaredFields();//获取这个类所有的成员变量
     
           for(Field field : fields) {
           
               System.out.print(field.getName() +"->");
               System.out.println(field.getModifiers());
     
           }
           
        }
    }
    
    

    运行结果:
    在这里插入图片描述

    通过返回的int类型的值,还是很难判断这些变量有哪些修饰符。

    在这里,需要用到 java.lang.reflect.Modifier 这个类。Modifier提供了很多静态方法。如public static String toString(int mod)就可以输出该整数对应的所有的修饰符。public static boolean isPublic(int mod)就可以判断该整数对应的是不是包含public修饰符。

    修改上面代码,把返回的整数转换通过Modifier转换一下:

    package com.caoguangli.reflect;
    
    import java.lang.reflect.Field;
    import java.lang.reflect.Modifier;
    
    public class MyTest {
    	
    	public int a;
    	 
        public static int b;
     
        public static final int c = 0;
     
        private int d;
    
    
    public static void main(String[] args) {
     
           Class<?> clazz = MyTest.class;
     
           Field[] fields = clazz.getDeclaredFields();//获取这个类所有的成员变量
     
           for(Field field : fields) {
             
                    System.out.print(field.getName() +"->");
                    System.out.println(Modifier.toString(field.getModifiers()));
    
           }
        }
    }
    
    

    运行结果:

    在这里插入图片描述
    通过Modifier的isPublic、isPrivate、isStatic等方法,可以判断是否包含某些修饰符,现在如果有这么一个需求,需要找到仅有public static两个修饰符的变量。

    访问修饰符列表

    public static final int PUBLIC = 0x00000001;
    public static final int PRIVATE = 0x00000002;
    public static final int PROTECTED = 0x00000004;
    public static final int STATIC = 0x00000008;
    public static final int FINAL = 0x00000010;
    public static final int SYNCHRONIZED = 0x00000020; 同步
    public static final int VOLATILE = 0x00000040; 用volatile修饰的变量,线程在每次使用变量的时候,都会读取变量修改后的最的值。
    public static final int TRANSIENT = 0x00000080; 用transient关键字标记的成员变量不参与序列化过程。
    public static final int NATIVE = 0x00000100;
    public static final int INTERFACE = 0x00000200;
    public static final int ABSTRACT = 0x00000400;
    public static final int STRICT = 0x00000800;
    即strictfp(strict float point 精确浮点),此关键字可应用于类、接口或方法。

    把它们转换成二进制,可以看出,Modifier使用一个二进制的位来表示是否包含某个修饰符。

    nativetransient
    publicprotected
    staticfinal
    synchronized

    也就是,如果是public static,对应的整数就是二进制的:1001,也就是9。如下图:

    public1
    static1
    private1
    final0

    如果是public static final就是11001,也就是25。

    现在如果想判断是否仅有public static两个修饰符,那么就可以判断是否field.getModifiers() == 9。

    另外,我们也可以看到这里设计之精妙之处:用二进制位来标记是否包含某个修饰符。

    反射详细网址:https://mp.csdn.net/mdeditor/91898501#

    展开全文
  • Jetpack Compose - Modifier入门篇

    千次阅读 2021-02-04 11:02:12
    Jetpack Compose - Modifier入门篇0、介绍1、属性一览1.1、androidx.compose.foundation.layout包1.2、androidx.compose.ui.draw包1.3、androidx.compose.foundation包2、使用示例2.1、paddingFromBaseline2.2、...
  • Music-Modifier-源码

    2021-04-15 14:45:03
    该项目报告详细介绍了为修改MIDI文件格式的音乐作品而创建的应用程序的开发和结果。 为此,该应用程序根据用户界面上用户定义的动作在实时回放期间修改了音乐。 用户可以更改诸如速度,音量,速度,音调和加载的....
  • 昨天给大家介绍了怎么进行同一个里面的方法调用,今天将会给大家说一下modifier以及不同之间怎么进行方法调用。 首先来说一下modifier。它有四个值:public,private,default,protected.其中,当你不声明...
  • 实用类介绍+jar包

    2020-07-30 19:05:42
    实用类介绍枚举定义枚举语法枚举性别枚举实例枚举的优点课堂笔记常用JavaAPI包装类包装类的作用包装类的目的装箱和拆箱包装类的常用方法Math类Math类常用方法介绍: 枚举 枚举指由一组固定的常量组成的类型 定义枚举...
  • 实用类介绍(枚举类型,包装类,Math类)一.枚举类型(Enum)1.定义2.定义枚举语法格式3.好处二.包装类1.定义2.作用3.包装类和基本数据类型的转换三.Math类 一.枚举类型(Enum) 1.定义 由一组固定的常量组成的类型...
  • Modifier是访问修饰符;枚举常量之间用逗号分隔;枚举常量列表以分号结尾。 里面的直接写的值都是该的公共静态常量,可以用类型.值的方式调用,可以和普通一样定义属性和方法。 valueOf方法常用来将该的枚举...
  •  [Modifier] enum enumName{  enumContantName1 [,enumConstantName...[;]] // [field, method] } enum:定义枚举的关键字 enumName:枚举的名字 底下的大括号里面是枚举里定义的常量 枚举里也可以有...
  • 一、Field的作用 Field是一个,位于java.lang.reflect包下。在Java反射中Field描述的是的属性信息,功能包括 (1)获取当前对象的成员变量的类型 (2)对成员变量重新设值 二、获取Field对象的四种方法 ...
  • 文章目录Java集合 1.体系结构与父类接口介绍1.集合体系结构2. Collection接口3. Map接口 Java集合 1.体系结构与父类接口介绍 1.集合体系结构 集合:可以存储任意类型的对象,并且长度可变。 集合都位于 ...
  • [Modifier]enum enumName{ enumContantName1[, enumConstantName2...[;]] //[field,method] }
  • highlight: a11y-dark theme: juejin 在之前的五篇文章中,我们已经无数次使用了技能系统中的Gameplay Effect,但是我们仅仅使用了最简单的部分,实际上GE的功能十分强大,接...GE修改Attributes是通过Modifier和Execu.
  • Rokon引擎主要类介绍

    2012-09-29 15:57:44
    Rokon:提供静态函数和属性 属性:circle,Polygon实例,圆形 ...Sprite的polygon属性默认为该矩形 函数:getActivity(),获取当前activity实例 -----------------------------------------
  • 多重modifire的执行顺序 我们在第一次介绍modifier的时候,就说他很像我们spring中的AOP,符合面向切面的思想。 下面我们看的这段代码,大家看看是不是更像呢? pragma solidity ^0.4.16; contract modifireTest4{ ...
  • 该篇文章内容主要集中Qt Creator软件欢迎界面部分代码的分析。从分析插件中的welcome模块开始,项目文件在路径\qt-creator-master\qt-...首先说明IntroductionWidget实现了UI Tour,也就是Qt Creator软件初次...
  • JAVA加载和反射介绍

    2017-10-05 13:05:18
    在java中,只要给定的名字,那么就可以通过反射机制来获得的所有信息. 反射机制的优点就是可以实现动态创建对象和编译,体现出很大的灵活性,特别是在J2EE的开发中它的灵活性就表现的十分明显。 当程序主动...
  • java 反射及辅助

    2018-11-27 21:30:52
    本文主要介绍反射的基本使用 目录 反射 反射作用及优缺点 Class类  创建Class对象的三种方式...Modifier类 Constructor类 代码示例:   反射 反射机制是指在程序运行状态中,对于任意一个类(只要知道类的...
  • Java加载和反射介绍

    2017-03-06 20:54:50
    简单的来说,反射机制指的是程序在运行时能够获取自身的信息。在java中,只要给定的名字,那么就可以通过反射机制来获得的所有信息.
  • 1.介绍 1.1使用反射 1.2反射的缺点 2.Class 2.1遍历对象 2.2检测修饰符与类型 2.3发现成员 翻译源:Java toturial 反射篇 1.介绍 1.1使用反射   反射提供了检测调节运行在jvm上的应用的运行时行为...
  • this.protectedMethod = Modifier.isProtected(method.getModifiers()); } @Override protected Object invokeJoinpoint() throws Throwable { if (this.protectedMethod) { return super....
  • this.cclass = (Modifier.isProtected(modifiers) && tclass.isAssignableFrom(caller) && !isSamePackage(tclass, caller)) ? caller : tclass; this.tclass = tclass; this.offset = U....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,199
精华内容 4,879
关键字:

modifier类的介绍