Modifier修饰符工具类

转载https://www.cnblogs.com/baiqiantao/p/7478523.html

作用：对类和成员访问修饰符进行解码

字段列表

• 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等类型的对象可以使用的所有修饰符。

//注意点：以下都是二进制的或运算,因为每个修饰符都独立的二进制位上标记1
private static final int CLASS_MODIFIERS =
    Modifier.PUBLIC         | Modifier.PROTECTED    | Modifier.PRIVATE |
    Modifier.ABSTRACT       | Modifier.STATIC       | Modifier.FINAL   |
    Modifier.STRICT;
	
//获取CLASS对象可以使用的所有修饰符
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;
//获取INTERFACE对象可以使用的所有修饰符
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;
}

//获取METHOD对象可以使用的所有修饰符
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;
}

//获取FIELD对象可以使用的所有修饰符
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;
//获取PARAMETER对象可以使用的所有修饰符
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 ");

        if ((len = sb.length()) > 0)    /* trim trailing space */
            return sb.toString().substring(0, len-1);
        return "";
    }

 

测试

public class ModifierTest {

    private static final transient int temp = 1;

    @Test
    public void test() throws  Exception {

        showModifier(ModifierTest.class.getDeclaredField("temp").getModifiers());
        showModifier(ModifierTest.class.getMethod("test").getModifiers());
    }
    public static void showModifier(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));
    }
}

输出：

----------------------【mod=154】----------------------
【toString】private static final transient
【isPublic】false
【isPrivate】true
【isProtected】false
【isStatic】true
【isFinal】true
【isSynchronized】false
【isVolatile】false
【isTransient】true
【isNative】false
【isInterface】false
【isAbstract】false
【isStrict】false
----------------------【mod=1】----------------------
【toString】public
【isPublic】true
【isPrivate】false
【isProtected】false
【isStatic】false
【isFinal】false
【isSynchronized】false
【isVolatile】false
【isTransient】false
【isNative】false
【isInterface】false
【isAbstract】false
【isStrict】false