接口回调

模板性代码：

[java] view plain copy

1. private MyListener myListener;  
2.   
3. public interface MyListener {  
4.     //通过抽象方法的参数传递数据的  
5.     void getData(Response res);  
6. }  
7.   
8. //回调方法  
9. public void setOnListener(MyListener myListener) {  
10.     this.myListener = myListener;  
11. }  

通过接口引用为抽象方法赋值

[java] view plain copy

1. myListener.getData(Response res);  

在另一个类中的某个方法中getNetData()进行回调网络请求结果

[java] view plain copy

1. CarGoodsFragment carGoodsFragment = CarGoodsFragment.getInstance("陈如水", 22);  
2. carGoodsFragment.setOnListener(this);  

流程是：

1）定义接口： 定义一个接口、定义其中的抽象方法、抽象方法含有参数(被传递的数据)；
2）编写回调方法： 在定义接口的类中，编写用户回调的方法，要传递一个接口对象实例，让别的类去实现。（相当于为接口成员变量赋值）
3）为抽象方法赋值： 获取一个全局的接口成员变量，在某个事件中使用接口成员变量调用接口中的方法，并且为抽象方法中的参数赋值。（这一步可以在回调方法中实现）


在另一个页面，在合适的时机，创建此类的实例，调用类中的回调方法，为接口对象赋值this，即可实现回调。

————————————————————————————————————————————————>

用接口回调封装网络请求: 模板性代码

登录模块：点击事件中的方法

[java] view plain copy

1. private void Login() {  
2.     //获取用户输入的参数  
3.     String pwd = et_pwd.getText().toString();  
4.     String login_name_put = et_login_name.getText().toString();  
5.   
6.     if (login_name_put == null || "".equals(login_name_put)) {  
7.         ToastUtils.showShort("请输入登录帐号");  
8.     } else if (pwd == null || "".equals(pwd)) {  
9.         ToastUtils.showShort("请输入登录密码");  
10.     } else {  
11.         HashMap<String, String> paramsMap = new HashMap<>();  
12.         //获取请求参数  
13.         paramsMap.put("login_name", login_name_put);  
14.         paramsMap.put("pwd", pwd);  
15.         HashMap<String, String> dataMap = ParamsUtils.getParamsMap(paramsMap);  
16.           
17.  //调取服务器端接口(网络请求业务类)  
18.         LoginManager loginManager = new LoginManager();  
19.         loginManager.login(LoginUI.this, LoginUI.this, dataMap);  
20.     }  
21. }  

实现接口，实现接口中的抽象方法：

[java] view plain copy

1. @Override  
2. public void loginSuccess(LoginEntity loginStatus) {  
3.     ToastUtils.showShort("登录成功");  
4.   
5.     //1，是否是第一次登录app  
6.     SPUtils.put(LoginUI.this, "LOGIN_STATE_FIRST", "2");  
7.     //2，存储获取到的SID  
8.     SPUtils.put(LoginUI.this, "SID", loginStatus.getSid());  
9.     //3，存储用户ID  
10.     SPUtils.put(LoginUI.this, "USER_ID", loginStatus.getId());  
11.     //4，保存用户的登录状态  
12.     SPUtils.put(LoginUI.this, "LOGIN_STATE", true);  
13.   
14.     //登录成功，直接进行页面跳转  
15.     startActivity(new Intent(LoginUI.this, MainUI.class));  
16.   
17.     finish();  
18. }  
19.   
20. @Override  
21. public void loginFail(String msg) {  
22.     loadFail(msg);  
23. }  

LoginManager里面的业务逻辑

[java] view plain copy

1. public class LoginManager {  
2.   
3.     public static void login(final LoginDataListener loginDataListener, Activity activity, Map<String, String> dataMap) {  
4.         NetUtils.addRequest(new GsonRequest<LoginEntity>  
5.                 (  
6.                         Request.Method.POST,//请求方式  
7.                         Constant.LOGIN,//请求地址  
8.                         LoginEntity.class,//返回实体类的封装  
9.                         dataMap,//请求参数  
10.                         new Response.Listener<LoginEntity>() {  
11.                             @Override  
12.                             public void onResponse(LoginEntity response) {  
13.                                 //在这里要判断响应码  
14.                                 if (response.isSuccess()) {  
15.                                     loginDataListener.loginSuccess(response);  
16.                                 } else {  
17.                                     loginDataListener.loginFail(TextUtils.isEmpty(response.getMessage()) ? "获取数据失败" : response.getMessage());  
18.                                 }  
19.                             }  
20.                         },  
21.                         new Response.ErrorListener() {  
22.                             @Override  
23.                             public void onErrorResponse(VolleyError error) {  
24.                                 LogUtils.i("test", error.getMessage());  
25.                             }  
26.                         }  
27.                 ), activity);  
28.     }  
29.   
30.     public interface LoginDataListener {  
31.         //激活成功后的数据  
32.         void loginSuccess(LoginEntity loginStatus);  
33.         void loginFail(String msg);  
34.     }  
35. }  

[java] view plain copy

1. RecycleView中的点击事件的写法  
2. //写一个接口  
3. public interface MyItemClickListener {  
4.     public void onItemClick(View view,int postion);  
5. }  
6.   
7. //写一个回调方法  
8. private MyItemClickListener mListener;  
9. public void setOnItemClickListener(MyItemClickListener listener){    
10.     this.mItemClickListener = listener;    
11. }    
12.   
13. //你想在什么时候触发此方法进行回调？  
14. @Override    
15. public void onClick(View v) {    
16.     if(mListener != null){    
17.         mListener.onItemClick(v,getPosition());    
18.     }    
19. }   

DownloadManager:具体的业务逻辑类，

在某一个Activity中，如果要处理下载逻辑，肯定要持有DownloadManager类的引用，创建这个类的对象，才能调用其中的方法；

 

用接口去规范行为（请求成功和请求失败这两种行为）

 

public interface OnDownloadListener{

//下载监听

}

 

在寻皮革项目中，我把所有的接口都写到业务逻辑类里面了，其实接口是可以单独抽取出来的。接口和业务逻辑类分开写。

 

需要一个接口的实现类：

1）让当前Activity实现接口，变成接口的实现类；

2）写一个类去实现接口，实现其中的抽象方法，然后在需要的地方创建一个接口实现类的子类对象

3）直接在当前位置使用匿名对象实现,创建一个接口实例。

 

回调原理：

接口调用自己的抽象方法，相当于接口的实现类调用实现类中重写的抽象方法；

 

接口中没有构造函数:

1）接口中是没有构造函数的，不能直接创建对象，只能由实现类创建对象；接口中的成员常量不需要进行初始化，所以不需要构造函数。

2）而抽象类是有构造方法的，为了给子类调用初始化抽象类中的成员变量。

 

接口的特点：

1）接口用关键字interface表示；类实现接口用implements表示。

2）接口不能实例化：那么，接口如何实例化呢?按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

3）接口的子类：要么是抽象类，要么重写接口中的所有抽象方法。

 

接口中的成员：

成员变量：只能是常量  默认修饰符 public static final(不能被修改)

构造方法：没有，因为接口主要是扩展功能的，而没有具体存在

成员方法：只能是抽象方法  默认修饰符 public abstract(可以省略)

 

类与类,类与接口以及接口与接口的关系：

类与类： 继承关系，只能单继承，但是可以多层继承

类与接口：实现关系，可以多实现,还可以在继承一个类的同时实现多个接口。

接口与接口：继承关系，可以单继承，也可以多继承。

定义一个接口:里面只放url的好处是？2不能被修改，直接类名点方法名调用。

接口用来解耦的，尽量不要在activity写太多的业务逻辑。