• Java基础——Modifier类

    转自：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.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)】的解码方法，且方法的实现也都是类似的，比如：

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

    新增的方法

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

    1. private static final int CLASS_MODIFIERS =
    2.     Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
    3.     Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
    4.     Modifier.STRICT;
    5. public static int classModifiers() {
    6.     return CLASS_MODIFIERS;
    7. }
    8.  
    9. private static final int INTERFACE_MODIFIERS =
    10.     Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
    11.     Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.STRICT;
    12. public static int interfaceModifiers() {
    13.     return INTERFACE_MODIFIERS;
    14. }
    15.  
    16. private static final int CONSTRUCTOR_MODIFIERS =
    17.     Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE;
    18. public static int constructorModifiers() {
    19.     return CONSTRUCTOR_MODIFIERS;
    20. }
    21.  
    22. private static final int METHOD_MODIFIERS =
    23.     Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
    24.     Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
    25.     Modifier.SYNCHRONIZED   | Modifier.NATIVE       | Modifier.STRICT;
    26. public static int methodModifiers() {
    27.     return METHOD_MODIFIERS;
    28. }
    29.  
    30. private static final int FIELD_MODIFIERS =
    31.     Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
    32.     Modifier.STATIC         | Modifier.FINAL        | Modifier.TRANSIENT |
    33.     Modifier.VOLATILE;
    34. public static int fieldModifiers() {
    35.     return FIELD_MODIFIERS;
    36. }
    37.  
    38. private static final int PARAMETER_MODIFIERS =
    39.     Modifier.FINAL;
    40. public static int parameterModifiers() {
    41.     return PARAMETER_MODIFIERS;
    42. }

    toString 方法的实现

    1. public static String toString(int mod) {
    2.     StringBuilder sb = new StringBuilder();
    3.     int len;
    4.  
    5.     if ((mod & PUBLIC) != 0)        sb.append("public ");
    6.     if ((mod & PROTECTED) != 0)     sb.append("protected ");
    7.     if ((mod & PRIVATE) != 0)       sb.append("private ");
    8.  
    9.     /* Canonical典范、规范 order */
    10.     if ((mod & ABSTRACT) != 0)      sb.append("abstract ");
    11.     if ((mod & STATIC) != 0)        sb.append("static ");
    12.     if ((mod & FINAL) != 0)         sb.append("final ");
    13.     if ((mod & TRANSIENT) != 0)     sb.append("transient ");
    14.     if ((mod & VOLATILE) != 0)      sb.append("volatile ");
    15.     if ((mod & SYNCHRONIZED) != 0)  sb.append("synchronized ");
    16.     if ((mod & NATIVE) != 0)        sb.append("native ");
    17.     if ((mod & STRICT) != 0)        sb.append("strictfp ");
    18.     if ((mod & INTERFACE) != 0)     sb.append("interface ");
    19.  
    20.     /* trim trailing space */
    21.     if ((len = sb.length()) > 0)  return sb.toString().substring(0, len-1);
    22.     return "";
    23. }

    示例1：解码mod演示

    1. public class Test {
    2. 	private static final transient int temp = 1;
    3.  
    4. 	public static void main(String[] args) throws Exception {
    5. 		testModifier(Test.class.getDeclaredField("temp").getModifiers());//154。private static final transient
    6. 		testModifier(Test.class.getMethod("main", String[].class).getModifiers());//9。public static
    7. 	}
    8.  
    9. 	public static void testModifier(int mod) {
    10. 		System.out.println("----------------------【mod=" + mod + "】----------------------");
    11. 		System.out.println("【toString】" + Modifier.toString(mod));
    12. 		System.out.println("【isPublic】" + Modifier.isPublic(mod));
    13. 		System.out.println("【isPrivate】" + Modifier.isPrivate(mod));
    14. 		System.out.println("【isProtected】" + Modifier.isProtected(mod));
    15. 		System.out.println("【isStatic】" + Modifier.isStatic(mod));
    16. 		System.out.println("【isFinal】" + Modifier.isFinal(mod));
    17. 		System.out.println("【isSynchronized】" + Modifier.isSynchronized(mod));
    18. 		System.out.println("【isVolatile】" + Modifier.isVolatile(mod));
    19. 		System.out.println("【isTransient】" + Modifier.isTransient(mod));
    20. 		System.out.println("【isNative】" + Modifier.isNative(mod));
    21. 		System.out.println("【isInterface】" + Modifier.isInterface(mod));
    22. 		System.out.println("【isAbstract】" + Modifier.isAbstract(mod));
    23. 		System.out.println("【isStrict】" + Modifier.isStrict(mod));
    24. 	}
    25. }

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

    1. System.out.println(Modifier.toString(Modifier.classModifiers()));//public protected private abstract static final strictfp
    2. System.out.println(Modifier.toString(Modifier.interfaceModifiers()));//public protected private abstract static strictfp
    3. System.out.println(Modifier.toString(Modifier.constructorModifiers()));//public protected private
    4. System.out.println(Modifier.toString(Modifier.methodModifiers()));//public protected private abstract static final synchronized native strictfp
    5. System.out.println(Modifier.toString(Modifier.fieldModifiers()));//public protected private static final transient volatile
    6. System.out.println(Modifier.toString(Modifier.parameterModifiers()));//final
  • 相关阅读:
    【css系列】创建网页加载进度条
    【大数据系列】apache hive 官方文档翻译
    【大数据系列】问题汇总
    【大数据系列】hive修改默认的derby数据库
    【大数据系列】hive安装及启动
    【大数据系列】MapReduce详解
    【大数据系列】基于MapReduce的数据处理 SequenceFile序列化文件
    【大数据系列】windows下连接Linux环境开发
    【大数据系列】常用命令
    【大数据系列】hadoop脚本分析
  • 原文地址：https://www.cnblogs.com/jpfss/p/11607595.html
Copyright © 2020-2023  润新知