长时间阅读Android SDK源码，会发现Google喜欢用位运算，伴随的是代码中会定义一堆int类型的常量，乍一看很懵逼，特别是所在View相关的类里边，比如这些常量你可熟悉：

    static final int FLAG_CLIP_CHILDREN = 0x1;

    private static final int FLAG_CLIP_TO_PADDING = 0x2;

    static final int FLAG_INVALIDATE_REQUIRED  = 0x4;

    private static final int FLAG_RUN_ANIMATION = 0x8;

    static final int FLAG_ANIMATION_DONE = 0x10;

    private static final int FLAG_PADDING_NOT_NULL = 0x20;

    private static final int FLAG_ANIMATION_CACHE = 0x40;

    static final int FLAG_OPTIMIZE_INVALIDATE = 0x80;

    static final int FLAG_CLEAR_TRANSFORMATION = 0x100;

又或者这种运算算，乍一看也不知道标识啥意思：

   // This is the original call.
            try {
                mGroupFlags |= FLAG_START_ACTION_MODE_FOR_CHILD_IS_NOT_TYPED;
                return startActionModeForChild(originalView, callback, ActionMode.TYPE_PRIMARY);
            } finally {
                mGroupFlags &= ~FLAG_START_ACTION_MODE_FOR_CHILD_IS_NOT_TYPED;
            }

Google常用套路：

1.int类型通过位运算存储boolean

下面我写个java文件，你可能一看就明白

public class Youyisi {

    private static final int BOOL01 = 1;
    private static final int BOOL02 = 1<<1;
    private static final int BOOL03 = 1<<3;
    private static final int BOOL04 = 1<<4;
    private static final int BOOL05 = 1<<5;
    private static final int BOOL06 = 1<<6;
    private static final int BOOL07 = 1<<7;
    private static final int BOOL08 = 1<<8;
    //most << 31
    

    private int flag;

    public void setBool01(boolean b){

        setBOOL(b, BOOL01);

    }
    public void setBool02(boolean b){

        setBOOL(b, BOOL02);

    }
    public void setBool03(boolean b){
        setBOOL(b, BOOL03);

    }
    public void setBool04(boolean b){
        setBOOL(b, BOOL04);

    }


    public boolean getBool1(){
        return getBOOL(BOOL01);
    }

    public boolean getBool2(){
        return getBOOL(BOOL02);
    }
    public boolean getBool3(){
        return getBOOL(BOOL03);
    }
    public boolean getBool4(){
        return getBOOL(BOOL04);
    }


    private boolean getBOOL(int FLAG){
        return (flag & FLAG) != 0;
    }


    private void setBOOL(boolean b,int FLAG){
        if (b == ((flag & FLAG) != 0)) {

            return;
        }
        if (b) {
            flag |= FLAG;
        } else {
            flag &= ~FLAG;
        }
    }

    public static void main(String[] args){
        Youyisi y = new Youyisi();
        y.setBool01(true);
        y.setBool02(true);
        y.setBool03(true);
        y.setBool04(true);
        boolean b  = y.getBool4();
        System.out.println(b);
    }
    
}

java中，int类型长度是32位，化成二进制，每一位上是0、1与否，都能代表一个boolean，所以一个int类型可以存储32个boolean值；
setBool过程分析：如果要给FLAG名下设置true，要做的事就是把flag对的FLAG有效位置1，所以就进行 flag |= FLAG运算；相反设置0，就进行 flag &= ~FLAG运算；
getBool过程分析：如果flag和FLAG按位想与结果为1，则为true，否则为false，所以采取(flag & FLAG) != 0;

2.多个相关联的int/bool/enum，通常按位存储在一个int类型中

什么意思呢，比如每一个都有性别和年龄，假设性别有男、女、未知三种，年龄是int类型的数值，最大值是300，那么就可以把性别和年龄存储在一个int类型中，这只是我简单的举例，看看Android自定义控件中有个MeasureSpec类，是如何将测量模式和size用同一个int表示；

常量的定义

        private static final int MODE_SHIFT = 30;
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

        /**
         * Measure specification mode: The parent has not imposed any constraint
         * on the child. It can be whatever size it wants.
         */
        public static final int UNSPECIFIED = 0 << MODE_SHIFT;

        /**
         * Measure specification mode: The parent has determined an exact size
         * for the child. The child is going to be given those bounds regardless
         * of how big it wants to be.
         */
        public static final int EXACTLY     = 1 << MODE_SHIFT;

        /**
         * Measure specification mode: The child can be as large as it wants up
         * to the specified size.
         */
        public static final int AT_MOST     = 2 << MODE_SHIFT;

构造方法就是合并的操作

 public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
                                          @MeasureSpecMode int mode) {
            if (sUseBrokenMakeMeasureSpec) {
                return size + mode;
            } else {
                return (size & ~MODE_MASK) | (mode & MODE_MASK);
            }
        }

分别获取模式和尺寸

//获取模式
 public static int getMode(int measureSpec) {
            //noinspection ResourceType
            return (measureSpec & MODE_MASK);
        }

//获取尺寸
 public static int getSize(int measureSpec) {
            return (measureSpec & ~MODE_MASK);
        }

分析：MODE_MASK=0x3 << MODE_SHIFT即把0x3向左移动30位，得到结果就是0x11000….000，一个30个0；
合并过程分析：如果sUseBrokenMakeMeasureSpec，sUseBrokenMakeMeasureSpec就是size和mode是做过运算的，得到的值是
直接相加size + mode，否则将size和mode坐位运算，得到的值高2位代码mode，低30位代表size；
获取的分析：获取分析比较简单，就直接分别获取高2位和低30位；

上面两个例子说明按位运算的强大之处，但是Java程序员似乎不习惯使用，因为习惯了面向对象，可能会在类中多定义几个属性，那样看起来还简单明了，何必绕来绕去的；但是位操作是不是略显逼格，就是cool，虽然不确定这样能优化多少，但google既然这样做，我们可以尝试追随；

总结：

其实这些都是计算机基础知识，只是上学时觉得没地方用，工作后也没有留意，至于要不要这样用，又是见仁见智的时候了。