Go语言视频零基础入门到精通

javalearner

1. 位操作就是将10进制数想为“01010000111”这样的2进制形式去运算、操作 常用运算符有|&<<>>^等
   
2. 在C++的开发里一般是不推荐使用位操作的，因为会降低代码的可读性。而且J2me开发中因为内存、运算速度等诸多原因，
3. 所以推荐使用位操作。
   
4. 实际应用1：按键处理
   
5. 首先在我们的主Canvas里要调用
   
6. /** *//**
   
7.       * 键盘接收
   
8.       */
   
9.      protected void keyPressed(int keyCode) {
   
10.          
    
11.          CType.setKeyState(keyCode);
    
12.          
    
13.      }
    
14. 
    
15.     /** *//**
    
16.      * 键盘放开处理
    
17.      */
    
18.     protected void keyReleased(int keyCode) {
    
19.         
    
20.         CType.clearKeyState(keyCode);
    
21.         
    
22.     }
    
23. 然后在我的CType里面：
    
24.   public static final int K_UP = 1;
    
25.       public static final int K_DOWN = 1 << 1;
    
26.       public static final int K_LEFT = 1 << 2;
    
27.       public static final int K_RIGHT = 1 << 3;
    
28.       public static final int K_FIRE = 1 << 4;
    
29.       public static final int K_COMMAND_LEFT = 1 << 5;
    
30.       public static final int K_COMMAND_RIGHT = 1 << 6;
    
31.       public static final int K_NUM1 = 1 << 7;
    
32.       public static final int K_NUM2 = 1 << 8;
    
33.      public static final int K_NUM3 = 1 << 9;
    
34.      public static final int K_NUM4 = 1 << 10;
    
35.      public static final int K_NUM5 = 1 << 11;
    
36.      public static final int K_NUM6 = 1 << 12;
    
37.      public static final int K_NUM7 = 1 << 13;
    
38.      public static final int K_NUM8 = 1 << 14;
    
39.      public static final int K_NUM9 = 1 << 15;
    
40.      public static final int K_NUM0 = 1 << 16;
    
41.      public static final int K_POUND = 1 << 17;
    
42.      public static final int K_STAR = 1 << 18;
    
43.      public static final int K_C = 1 << 19;
    
44.      
    
45.      public static final int COMMAND_UP = K_UP | K_NUM2;
    
46.      public static final int COMMAND_DOWN = K_DOWN | K_NUM8;
    
47.      public static final int COMMAND_LEFT = K_LEFT | K_NUM4;
    
48.      public static final int COMMAND_RIGHT = K_RIGHT | K_NUM6;
    
49.      public static int COMMAND_OK = K_FIRE | K_NUM5;
    
50.      public static int COMMAND_BACK = isleft ? K_COMMAND_RIGHT : K_COMMAND_LEFT;
    
51.      public static int COMMAND_LEFT_OK = isleft ? K_COMMAND_LEFT : K_COMMAND_RIGHT;
    
52.      
    
53.      public static int key = 0;
    
54.      /**//*============================= keycode ==========================*/
    
55.      // nokia
    
56.     public static int UP = -1;
    
57.      public static int DOWN = -2;
    
58.      public static int LEFT = -3;
    
59.      public static int RIGHT = -4;
    
60.      public static int FIRE = -5;
    
61.      public static int SOFT_LEFT = -6;
    
62.      public static int SOFT_RIGHT = -7;
    
63.      public static int NUM0 = 48;
    
64.      public static int NUM1 = 49;
    
65.      public static int NUM2 = 50;
    
66.      public static int NUM3 = 51;
    
67.      public static int NUM4 = 52;
    
68.      public static int NUM5 = 53;
    
69.      public static int NUM6 = 54;
    
70.      public static int NUM7 = 55;
    
71.      public static int NUM8 = 56;
    
72.      public static int NUM9 = 57;
    
73.      public static int POUND = 35;// #
    
74.      public static int ASTERISK = 42;// *
    
75.      public static int SEND = -10;//
    
76.      public static int END = -11;//
    
77.      public static int POWER = -12;
    
78.      public static int SOFT3 = -20;
    
79.      public static int CLEAR = -8;//
    
80.      public static void setKeyState(int keyCode){
    
81.          
    
82.          if(keyCode == UP)         
    
83.              key |= K_UP;
    
84.          else if(keyCode == DOWN)
    
85.             
    
86.              key |= K_DOWN;      
    
87.          else if(keyCode == LEFT)            
    
88.              key |= K_LEFT;
    
89.          else if(keyCode == RIGHT)
    
90.             
    
91.              key |= K_RIGHT;
    
92.          else if(keyCode == FIRE)
    
93.             
    
94.              key |= K_FIRE;
    
95.          
    
96.          else if(keyCode == SOFT_LEFT)
    
97.             
    
98.             key |= K_COMMAND_LEFT;
    
99.          
    
100.          else if(keyCode == SOFT_RIGHT)
     
101.             
     
102.            key |= K_COMMAND_RIGHT;
     
103.          
     
104.          else if(keyCode == NUM0)
     
105.             
     
106.              key |= K_NUM0;
     
107.          
     
108.          else if(keyCode == NUM1)
     
109.             
     
110.              key |= K_NUM1;
     
111.          
     
112.          else if(keyCode == NUM2)
     
113.             
     
114.              key |= K_NUM2;
     
115.          
     
116.          else if(keyCode == NUM3)
     
117.             
     
118.             key |= K_NUM3;
     
119.         
     
120.        else if(keyCode == NUM4)
     
121.             
     
122.             key |= K_NUM4;
     
123.         
     
124.         else if(keyCode == NUM5)
     
125.             
     
126.             key |= K_NUM5;
     
127.         
     
128.         else if(keyCode == NUM6)
     
129.             
     
130.             key |= K_NUM6;
     
131.         
     
132.         else if(keyCode == NUM7)
     
133.             
     
134.             key |= K_NUM7;
     
135.         
     
136.         else if(keyCode == NUM8)
     
137.             
     
138.            key |= K_NUM8;
     
139.         
     
140.         else if(keyCode == NUM9)
     
141.             
     
142.             key |= K_NUM9;
     
143.         
     
144.         else if(keyCode == POUND)
     
145.             
     
146.             key |= K_POUND;
     
147.         
     
148.         else if(keyCode == ASTERISK)
     
149.             
     
150.             key |= K_STAR;
     
151.         
     
152.         if(doublePressedTimer < DOUBLE_PRESSED_TIMER
     
153.                && lastDoublePressedKey == keyCode){
     
154.             
     
155.             doublePressed = true;
     
156.             
     
157.         }else{
     
158.             
     
159.             doublePressed = false;
     
160.             
     
161.         }
     
162.         
     
163.     }
     
164.    
     
165.    public static void clearAllKeyState(){      
     
166.         key = 0;
     
167.         
     
168.     }
     
169.    
     
170.     public static void clearKeyState(int keyCode){      
     
171.         if(keyCode == UP)      
     
172.             key  &= (K_UP ^ 0xffffffff);
     
173.         
     
174.         else if(keyCode == DOWN)
     
175.             
     
176.             key  &= (K_DOWN ^ 0xffffffff);
     
177.         
     
178.         else if(keyCode == LEFT)
     
179.             
     
180.             key  &= (K_LEFT ^ 0xffffffff);
     
181.         
     
182.         else if(keyCode == RIGHT)
     
183.             
     
184.             key  &= (K_RIGHT ^ 0xffffffff);
     
185.         
     
186.        else if(keyCode == FIRE)
     
187.             
     
188.             key  &= (K_FIRE ^ 0xffffffff);
     
189.         
     
190.         else if(keyCode == SOFT_LEFT)
     
191.             
     
192.            key  &= (K_COMMAND_LEFT ^ 0xffffffff);
     
193.         
     
194.         else if(keyCode == SOFT_RIGHT)
     
195.             
     
196.             key  &= (K_COMMAND_RIGHT ^ 0xffffffff);
     
197.         
     
198.         else if(keyCode == NUM0)
     
199.             
     
200.             key  &= (K_NUM0 ^ 0xffffffff);
     
201.         
     
202.         else if(keyCode == NUM1)
     
203.             
     
204.             key  &= (K_NUM1 ^ 0xffffffff);
     
205.         
     
206.         else if(keyCode == NUM2)
     
207.             
     
208.             key  &= (K_NUM2 ^ 0xffffffff);
     
209.       
     
210.         else if(keyCode == NUM3)
     
211.             
     
212.             key  &= (K_NUM3 ^ 0xffffffff);
     
213.       
     
214.         else if(keyCode == NUM4)
     
215.             
     
216.             key  &= (K_NUM4 ^ 0xffffffff);
     
217.         
     
218.         else if(keyCode == NUM5)
     
219.             
     
220.            key  &= (K_NUM5 ^ 0xffffffff);
     
221.         
     
222.         else if(keyCode == NUM6)
     
223.             
     
224.             key  &= (K_NUM6 ^ 0xffffffff);
     
225.         
     
226.         else if(keyCode == NUM7)
     
227.             
     
228.             key  &= (K_NUM7 ^ 0xffffffff);
     
229.         
     
230.         else if(keyCode == NUM8)
     
231.             
     
232.             key  &= (K_NUM8 ^ 0xffffffff);
     
233.         
     
234.         else if(keyCode == NUM9)
     
235.             
     
236.             key  &= (K_NUM9 ^ 0xffffffff);
     
237.         
     
238.         else if(keyCode == POUND)
     
239.             
     
240.             key  &= (K_POUND ^ 0xffffffff);
     
241.       
     
242.         else if(keyCode == ASTERISK)
     
243.             
     
244.             key  &= (K_STAR ^ 0xffffffff);
     
245.         
     
246.         lastDoublePressedKey = keyCode;
     
247.       
     
248.         doublePressedTimer = 0;
     
249.       
     
250.     }
     
251.    
     
252.     public static boolean getKeyState(int command){
     
253.         
     
254.         return (key & command) != 0;
     
255.         
     
256.     }
     
257.    
     
258.     public static boolean getKeyStateOnce(int command){
     
259.         
     
260.         boolean tmp = (key & command) != 0;
     
261.         
     
262.         if(tmp) clearAllKeyState();
     
263.         
     
264.             return tmp;
     
265.     }
     
266.    
     
267.     public static boolean haveKeyPressedEvent(){
     
268.         
     
269.         return key != 0;
     
270.         
     
271.     }
     
272.    
     
273.     /** *//**
     
274.      * 双击方向键上
     
275.      * @return
     
276.      */
     
277.     public static boolean doubleCommandUp(){
     
278.         
     
279.         return getKeyState(COMMAND_UP) && doublePressed;
     
280.       
     
281.     }
     
282.    
     
283.    /** *//**
     
284.      * 双击方向键下
     
285.      * @return
     
286.      */
     
287.     public static boolean doubleCommandDown(){
     
288.       
     
289.         return getKeyState(COMMAND_DOWN) && doublePressed;
     
290.       
     
291.     }
     
292.    
     
293.     /** *//**
     
294.      * 双击方向键左
     
295.      * @return
     
296.      */
     
297.     public static boolean doubleCommandLeft(){
     
298.         
     
299.         return getKeyState(COMMAND_LEFT) && doublePressed;
     
300.         
     
301.     }
     
302.    
     
303.     /** *//**
     
304.      * 双击方向键右
     
305.      * @return
     
306.      */
     
307.     public static boolean doubleCommandRight(){
     
308.         
     
309.         return getKeyState(COMMAND_RIGHT) && doublePressed;
     
310.         
     
311.     }
     
312.    
     
313.    /** *//**
     
314.      * 双击方向键确定
     
315.      * @return
     
316.      */
     
317.     public static boolean doubleCommandOK(){
     
318.       
     
319.         return getKeyState(COMMAND_OK) && doublePressed;
     
320.         
     
321.     }
     
322.    
     
323.     /** *//**
     
324.      * 按下方向键上
     
325.      * @return
     
326.      */
     
327.     public static boolean commandUp(){
     
328.         
     
329.         return getKeyState(COMMAND_UP);
     
330.         
     
331.     }
     
332.    
     
333.     /** *//**
     
334.      * 按下方向键下
     
335.      * @return
     
336.      */
     
337.     public static boolean commandDown(){
     
338.         
     
339.         return getKeyState(COMMAND_DOWN);
     
340.         
     
341.     }
     
342.    
     
343.     /** *//**
     
344.      * 按下方向键左
     
345.      * @return
     
346.      */
     
347.     public static boolean commandLeft(){
     
348.         
     
349.         return getKeyState(COMMAND_LEFT);
     
350.         
     
351.     }
     
352.    
     
353.     /** *//**
     
354.      * 按下方向键右
     
355.      * @return
     
356.      */
     
357.     public static boolean commandRight(){
     
358.         
     
359.         return getKeyState(COMMAND_RIGHT);
     
360.         
     
361.     }
     
362.    
     
363.     /** *//**
     
364.      * 按下方向键确定
     
365.      * @return
     
366.      */
     
367.     public static boolean commandOK(){
     
368.         
     
369.         return getKeyState(COMMAND_OK);
     
370.      
     
371.     }
     
372.    
     
373.     /** *//**
     
374.      * 按下确定软键
     
375.      * @return
     
376.      */
     
377.     public static boolean commandLeftOk(){
     
378.       
     
379.         return getKeyState(COMMAND_LEFT_OK);
     
380.       
     
381.     }
     
382.   
     
383.     /** *//**
     
384.      * 按下取消软键
     
385.      * @return
     
386.     */
     
387.     public static boolean commandBack(){
     
388.         
     
389.       return getKeyState(COMMAND_BACK);
     
390.         
     
391.     }
     
392.    
     
393.    /** *//**
     
394.     * 单击方向键上一次
     
395.     * @return
     
396.     */
     
397.    public static boolean commandUpOnce(){
     
398.         
     
399.         boolean r = commandUp();
     
400.         
     
401.         if(r)
     
402.             
     
403.             clearAllKeyState();
     
404.         
     
405.         return r;
     
406.         
     
407.     }
     
408.    
     
409.     /** *//**
     
410.      * 单击方向键下一次
     
411.      * @return
     
412.      */
     
413.     public static boolean commandDownOnce(){
     
414.         
     
415.         boolean r = commandDown();
     
416.         
     
417.         if(r)
     
418.             
     
419.             clearAllKeyState();
     
420.         
     
421.         return r;
     
422.         
     
423.     }
     
424.    
     
425.     /** *//**
     
426.      * 单击方向键左一次
     
427.      * @return
     
428.      */
     
429.     public static boolean commandLeftOnce(){
     
430.         
     
431.         boolean r = commandLeft();
     
432.         
     
433.         if(r)
     
434.             
     
435.             clearAllKeyState();
     
436.         
     
437.         return r;
     
438.         
     
439.     }
     
440. 
     
441.     /** *//**
     
442.     * 单击方向键右一次
     
443.     * @return
     
444.      */
     
445.     public static boolean commandRightOnce(){
     
446.         
     
447.         boolean r = commandRight();
     
448.         
     
449.         if(r)
     
450.             
     
451.             clearAllKeyState();
     
452.         
     
453.        return r;
     
454.       
     
455.     }
     
456.    
     
457.     /** *//**
     
458.      * 单击确定键一次
     
459.      * @return
     
460.      */
     
461.     public static boolean commandOkOnce(){
     
462.         
     
463.         boolean r = commandOK();
     
464.         
     
465.         if(r)
     
466.             
     
467.             clearAllKeyState();
     
468.         
     
469.         return r;
     
470.         
     
471.     }
     
472.    
     
473.     /** *//**
     
474.      * 单击确定软键一次
     
475.      * @return
     
476.      */
     
477.    public static boolean commandLeftOkOnce(){
     
478.         
     
479.         boolean r = commandLeftOk();
     
480.         
     
481.         if(r)
     
482.             
     
483.             clearAllKeyState();
     
484.         
     
485.         return r;
     
486.         
     
487.     }
     
488.    
     
489.     /** *//**
     
490.      * 单击取消软键一次
     
491.      * @return
     
492.     */
     
493.     public static boolean commandBackOnce(){
     
494.         
     
495.         boolean r = commandBack();
     
496.         
     
497.         if(r)
     
498.             
     
499.             clearAllKeyState();
     
500.         
     
501.        return r;
     
502.         
     
503.     }
     
504.   就是一串的01010101010010000每个位都代表一个按键 当他是1的时候就是按下了 0就表示没被按下.
     
505. 实际应用2：效果Buffer
     
506. // 比如这里我们定义一些技能效果
     
507. static final int
     
508. SKILL_BUFFER_燃烧 = 1,
     
509. SKILL_BUFFER_眩晕 = 1 << 1,
     
510. SKILL_BUFFER_攻击力X2 = 1 << 2,
     
511. SKILL_BUFFER_必闪 = 1 << 3;
     
512. // 为什么不写成
     
513. // SKILL_BUFFER_燃烧 = 1,
     
514. // SKILL_BUFFER_眩晕 = 2,
     
515. // SKILL_BUFFER_攻击力X2 = 3,
     
516. // SKILL_BUFFER_必闪 = 4; 呢？
     
517. // 因为有可能我身上的效果是很多叠在一起的
     
518. // 我可能身上又着火又眩晕
     
519. // 用位操作就可以实现多状态buffer的共存
     
520. public void setBuffer_燃烧(){
     
521.     buffer |= SKILL_BUFFER_燃烧;
     
522. }
     
523. public void clearBuffer_燃烧(){
     
524. }
     
525. public boolean isBuffer_燃烧(){
     
526.     return (buffer & SKILL_BUFFER_燃烧) != 0;
     
527. }
     
528. 实际应用3：整型保存数据
     
529. 在实际开发的时候，有时候我们想把多个数字保存在一个int里面，那么可以这样
     
530. /** *//**
     
531.       * 将一个数保存在整数里
     
532.       * @param src 原始数据
     
533.       * @param num 要保存的数据
     
534.       * @param begin  从第几位开始写
     
535.       * @return
     
536.       */
     
537.      public static int setBit(int src, int num, int begin){
     
538.          return src | (num << begin);
     
539.     }
     
540.    
     
541.     /** *//**
     
542.      * 得到一个整数的某几位
     
543.      * @param src 原数据
     
544.      * @param begin 从第几位开始获取
     
545.      * @param len 获取长度多少位
     
546.      * @return
     
547.      */
     
548.     public static int getBit(int src, int begin, int len){
     
549.         return (src & getDec(begin, len)) >> begin;
     
550.     }
     
551.    
     
552.     private static int getDec(int begin, int len){
     
553.         int k = 0;
     
554.         for(int i = 0; i < len; ++i){
     
555.             k |= (1 << i);
     
556.        }
     
557.         return k << begin;
     
558.     }
     
559.   这个在实际开发中是常用的，比如我的地图数据，其图块编号也就 0～100多那么我可以把多层的同一个格子的数据写到一个int里面
     
560. 注意不要存负数就可以了，因为负数前面可有一位符号位哦.

复制代码