[转]Android中handler总结

1. public class HandlerActivity extends Activity {  
2.      
3.     //声明两个按钮控件  
4.     private Button startButton = null;  
5.     private Button endButton = null;  
6.     @Override 
7.     public void onCreate(Bundle savedInstanceState) {  
8.         super.onCreate(savedInstanceState);  
9.         setContentView(R.layout.main);  
10.          //根据控件的ID得到代表控件的对象，并为这两个按钮设置相应的监听器  
11.          startButton = (Button)findViewById(R.id.startButton);  
12.          startButton.setOnClickListener(new StartButtonListener());  
13.          endButton = (Button)findViewById(R.id.endButton);  
14.          endButton.setOnClickListener(new EndButtonListener());  
15.            
16.      }  
17.      class StartButtonListener implements OnClickListener{  
18.   
19.          @Override 
20.          public void onClick(View v) {  
21.              //调用Handler的post方法，将要执行的线程对象添加到队列当中  
22.              handler.post(updateThread);  
23.          }  
24.            
25.      }  
26.        
27.      class EndButtonListener implements OnClickListener{  
28.   
29.          @Override 
30.          public void onClick(View v) {  
31.             handler.removeCallbacks(updateThread);  
32.          }  
33.           
34.      }  
35.      //创建一个Handler对象  
36.      Handler handler  = new Handler();  
37.      //将要执行的操作写在线程对象的run方法当中  
38.      Runnable updateThread =  new Runnable(){  
39.   
40.          @Override 
41.          public void run() {  
42.              System.out.println("UpdateThread");  
43.              //在run方法内部，执行postDelayed或者是post方法  
44.              handler.postDelayed(this, 3000);  
45.          }  
46.            
47.      };  

48. } 

1. public class HandlerTest2 extends Activity {  
2.  
3.     @Override 
4.     protected void onCreate(Bundle savedInstanceState) {  
5.         // TODO Auto-generated method stub  
6.     super.onCreate(savedInstanceState);  
7.     setContentView(R.layout.main);  
8.     //打印了当前线程的ID  
9.     System.out.println("Activity-->" + Thread.currentThread().getId());  
10.      //生成一个HandlerThread对象  
11.      HandlerThread handlerThread = new HandlerThread("handler_thread");  
12.      //在使用HandlerThread的getLooper()方法之前，必须先调用该类的start()，同时开启一个新线程;  
13.      handlerThread.start();
14.      //将由HandlerThread获取的Looper传递给Handler对象，即由处于另外线程的Looper代替handler初始化时默认绑定的消息队列来处理消息。  
15.       // HandlerThread顾名思义就是可以处理消息循环的线程，它是一个拥有Looper的线程

16. ，可以处理消息循环；  其实与其说Handler和一个线程绑定，倒不如说Handler和Looper是

17. 一一对应的。

1.      MyHandler myHandler = new MyHandler(handlerThread.getLooper());  
2.      Message msg = myHandler.obtainMessage();  
3.      //将msg发送到目标对象，所谓的目标对象，就是生成该msg对象的handler对象  
4.      Bundle b = new Bundle();  
5.      b.putInt("age", 20);  
6.      b.putString("name", "Jhon");  
7.      msg.setData(b);  
8.      msg.sendToTarget();  //将msg发送到myHandler
9.      }  
10.        
11.      //定义类
12.      class MyHandler extends Handler{  
13.      public MyHandler(){  
14.                
15.      }  
16.      
17.     public MyHandler(Looper looper){  
18.         super(looper);  
19.      }  
20.      @Override 
21.      public void handleMessage(Message msg) {  
22.         Bundle b = msg.getData();  
23.         int age = b.getInt("age");  
24.         String name = b.getString("name");  
25.          System.out.println("age is " + age + ", name is" + name);  
26.          System.out.println("Handler--->" + Thread.currentThread().getId());  
27.          System.out.println("handlerMessage");  
28.          }  
29.      }  

47. }