详解Android接口Interface的使用和意义

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/mr_jianrong/article/details/80203771

本文介绍是Android的一个重要的东西，接口Interface，详解两个方面：

（1）Java是继承的，接口Interface是可以多个的，恰恰弥补了这个缺点。

（2）回调，接口Interface里面的是抽象方法，需要回调进行相应操作。

通俗地讲讲上面两点讲的是什么（懂了就不用看了，直接看demo分析）

首先简述一下View.OnClickListener接口，View这个类里面就有一个OnClickListener的接口，里面的抽象方法是onClick方法，抽象的方法需要实现它，所以在setOnClickListener方法中开放出来。

1.平时我们既可以extends Activity，又可以通过implements View.OnClickListener，有Activity的特性同时又可以设置监听器，这就是接口弥补了Java单继承的缺点。

2.我们可以随意地写setOnClickListener(参数)，参数是一个OnClickListener接口的实现类，也就是说View.OnClickListener这个接口可以在其他地方实现，我们平时用setOnClickListener用得那么爽就是因为回调，回调就是有这好处。

接下来，如果还有疑惑，结合代码再详细并且通俗地讲，我写了个接口用法的demo：

NetWorkCallbackInterface.java，这是一个定义接口的java文件，名叫NetWorkCallbackInterface的接口，抽象方法是showCallback(String result)。

[java]  view plain  copy

1. package com.example.networldemo;  
2.   
3. public interface NetWorkCallbackInterface {  
4.     void showCallback(String result);  
5. }  

MainActivity.java，这是一个Activity，同时也implements接口NetWorkCallbackInterface，其他代码不用看，就看showCallback(String result)，这里方法实现的是，handler调用更新界面，接下来看看在哪里可以调用这个呢。

看看下面Button的点击监听事件：

1.第一句final HttpUtil util=new HttpUtil(MainActivity.this)。我在HttpUtil这个类的构造方法要求传NetWorkCallbackInterface对象过去，为什么这里的参数是MainActivity.this而不是new一个NetWorkCallbackInterface对象呢，因为我的Activity是implements了NetWorkCallbackInterface，Activity本身就有这个NetWorkCallbackInterface接口特点，不然showCallback(String result)为何要在这里实现呢。

2.后面几句，在非主线程中执行HttpUtil 对象里面的GetNow方法，这个方法做了什么，下面看下一段解析和代码HttpUtil.java。

[java]  view plain  copy

1. package com.example.networldemo;  
2.   
3. import java.util.concurrent.ExecutorService;  
4. import java.util.concurrent.Executors;  
5.   
6. import android.app.Activity;  
7. import android.os.Bundle;  
8. import android.os.Handler;  
9. import android.os.Message;  
10. import android.view.View;  
11. import android.view.View.OnClickListener;  
12. import android.widget.Button;  
13. import android.widget.TextView;  
14.   
15. public class MainActivity extends Activity implements NetWorkCallbackInterface{  
16.   
17.     Button start;  
18.     TextView tv;  
19.     ExecutorService pool;  
20.       
21.     Handler handler=new Handler(){  
22.         @Override  
23.         public void handleMessage(Message msg) {  
24.             // TODO Auto-generated method stub  
25.             super.handleMessage(msg);  
26.             if(msg.what==1){  
27.                 tv.setText(msg.obj.toString());  
28.             }  
29.         }  
30.     };  
31.     //NetWorkCallbackInterface的实现方法  
32.     @Override  
33.     public void showCallback(String result) {  
34.         Message msg=new Message();  
35.         msg.what=1;  
36.         msg.obj=result;  
37.         handler.sendMessage(msg);  
38.     }  
39.       
40.     @Override  
41.     protected void onCreate(Bundle savedInstanceState) {  
42.         super.onCreate(savedInstanceState);  
43.         setContentView(R.layout.activity_main);  
44.           
45.         pool=Executors.newSingleThreadExecutor();  
46.         init();  
47.     }  
48.     private void init() {  
49.         start=(Button) findViewById(R.id.start);  
50.         start.setOnClickListener(new OnClickListener() {  
51.             @Override  
52.             public void onClick(View v) {  
53.                 final HttpUtil util=new HttpUtil(MainActivity.this);  
54.                 pool.execute(new Thread(new Runnable() {  
55.                     @Override  
56.                     public void run() {  
57.                         util.GetNow();    
58.                     }  
59.                 }));  
60.             }  
61.         });  
62.         tv=(TextView) findViewById(R.id.display_result);  
63.     }  
64. }  

HttpUtil.java，其他代码也不用看，看我说的代码就够了。

1.回顾：上面说到，Activity中已经有NetWorkCallbackInterface的特性了，抽象方法也在Activity中实现了，所以，在HttpUtil构造方法中，传过去给HttpUtil的是MainActivity.this，但构造方法public HttpUtil(NetWorkCallbackInterface callback)的参数明明是NetWorkCallbackInterface类型，Activity中已经有NetWorkCallbackInterface的特性了，所以参数无争议成立的。

2.在构造方法中，把MainActivity.this复制本类中的NetWorkCallbackInterface对象callback后，再看public void GetNow()方法，里面实现是callback.showCallback(doGet("http://wwww.baidu.com", null))，callback对象会调用它的showCallback方法了，参数是doGet方法，不用看这方法，它会返回一个String的值就是了。这个showCallback方法就是MainActivity中的showCallback方法，因为本类的NetWorkCallbackInterface对象就是从MainActivity中传过来的，不然怎么叫回调。

[java]  view plain  copy

1. package com.example.networldemo;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.IOException;  
5. import java.io.InputStream;  
6. import java.io.InputStreamReader;  
7. import java.net.HttpURLConnection;  
8. import java.net.MalformedURLException;  
9. import java.net.URL;  
10.   
11.   
12. public class HttpUtil {  
13.     private NetWorkCallbackInterface callback;  
14.       
15.     private final int CONNECT_TIME_OUT = 5 * 1000;  
16.     private final int READ_TIME_OUT = 10 * 1000;  
17.       
18.     /* 
19.      * start---------------------------------------- 
20.      * 其他不用看，今天的主角是这里，回调。 
21.      */  
22.     public HttpUtil(NetWorkCallbackInterface callback) {  
23.         this.callback=callback;  
24.     }  
25.     public void GetNow(){  
26.         callback.showCallback(doGet("http://wwww.baidu.com", null));  
27.     }  
28.     /* 
29.      * ----------------------------------------end 
30.      */  
31.       
32.     private URL url = null;  
33.     private HttpURLConnection uRLConnection_GET;  
34.   
35.     // 向服务器发送get请求  
36.     private String doGet(String urlAddress, String params) {  
37.         if (params == null)  
38.             params = "";  
39.         try {  
40.             url = new URL(urlAddress + params);  
41.             uRLConnection_GET = (HttpURLConnection) url.openConnection();  
42.             // 接连超时  
43.             uRLConnection_GET.setConnectTimeout(CONNECT_TIME_OUT);  
44.             // 响应超时  
45.             uRLConnection_GET.setReadTimeout(READ_TIME_OUT);  
46.             InputStream is = uRLConnection_GET.getInputStream();  
47.             BufferedReader br = new BufferedReader(new InputStreamReader(is));  
48.             String response = "";  
49.             String readLine = null;  
50.             while ((readLine = br.readLine()) != null) {  
51.                 response = response + readLine;  
52.             }  
53.             is.close();  
54.             br.close();  
55.             uRLConnection_GET.disconnect();  
56.             return response;  
57.         } catch (MalformedURLException e) {  
58.             e.printStackTrace();  
59.             return null;  
60.         } catch (IOException e) {  
61.             e.printStackTrace();  
62.             return null;  
63.         }  
64.     }  
65. }  

从上面的demo，一句话总结：接口可以让你的类拓展出丰富的特性，回调可以让其他的类享受该类的丰富的特性(本例demo) 或者 其他类具体实现该类的更多特性（View.OnClick）。

很通俗很直白的《Android接口Interface的使用和意义》到此完毕了。

看完全文不懂的也不要灰心，刚开始接触接口Interface的时候，我也一头雾水了，多看几次概念和多敲几次代码，就可以懂的。

demo附上链接：http://download.csdn.net/detail/qq_29623203/9496398