接口回调（重点是理解）

模板性代码：

    private MyListener myListener;
    
    public interface MyListener {
        //通过抽象方法的参数传递数据的
        void getData(Response res);
    }
 
    //回调方法
    public void setOnListener(MyListener myListener) {
        this.myListener = myListener;
    }

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

    myListener.getData(Response res);

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

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

流程是：

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


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

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

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

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

    private void Login() {
        //获取用户输入的参数
        String pwd = et_pwd.getText().toString();
        String login_name_put = et_login_name.getText().toString();
 
        if (login_name_put == null || "".equals(login_name_put)) {
            ToastUtils.showShort("请输入登录帐号");
        } else if (pwd == null || "".equals(pwd)) {
            ToastUtils.showShort("请输入登录密码");
        } else {
            HashMap<String, String> paramsMap = new HashMap<>();
            //获取请求参数
            paramsMap.put("login_name", login_name_put);
            paramsMap.put("pwd", pwd);
            HashMap<String, String> dataMap = ParamsUtils.getParamsMap(paramsMap);
            
	    //调取服务器端接口(网络请求业务类)
            LoginManager loginManager = new LoginManager();
            loginManager.login(LoginUI.this, LoginUI.this, dataMap);
        }
    }

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

    @Override
    public void loginSuccess(LoginEntity loginStatus) {
        ToastUtils.showShort("登录成功");
 
        //1，是否是第一次登录app
        SPUtils.put(LoginUI.this, "LOGIN_STATE_FIRST", "2");
        //2，存储获取到的SID
        SPUtils.put(LoginUI.this, "SID", loginStatus.getSid());
        //3，存储用户ID
        SPUtils.put(LoginUI.this, "USER_ID", loginStatus.getId());
        //4，保存用户的登录状态
        SPUtils.put(LoginUI.this, "LOGIN_STATE", true);
 
        //登录成功，直接进行页面跳转
        startActivity(new Intent(LoginUI.this, MainUI.class));
 
        finish();
    }
 
    @Override
    public void loginFail(String msg) {
        loadFail(msg);
    }

LoginManager里面的业务逻辑

public class LoginManager {
 
    public static void login(final LoginDataListener loginDataListener, Activity activity, Map<String, String> dataMap) {
        NetUtils.addRequest(new GsonRequest<LoginEntity>
                (
                        Request.Method.POST,//请求方式
                        Constant.LOGIN,//请求地址
                        LoginEntity.class,//返回实体类的封装
                        dataMap,//请求参数
                        new Response.Listener<LoginEntity>() {
                            @Override
                            public void onResponse(LoginEntity response) {
                                //在这里要判断响应码
                                if (response.isSuccess()) {
                                    loginDataListener.loginSuccess(response);
                                } else {
                                    loginDataListener.loginFail(TextUtils.isEmpty(response.getMessage()) ? "获取数据失败" : response.getMessage());
                                }
                            }
                        },
                        new Response.ErrorListener() {
                            @Override
                            public void onErrorResponse(VolleyError error) {
                                LogUtils.i("test", error.getMessage());
                            }
                        }
                ), activity);
    }
 
    public interface LoginDataListener {
        //激活成功后的数据
        void loginSuccess(LoginEntity loginStatus);
        void loginFail(String msg);
    }
}

RecycleView中的点击事件的写法
//写一个接口
public interface MyItemClickListener {
    public void onItemClick(View view,int postion);
}
 
//写一个回调方法
private MyItemClickListener mListener;
public void setOnItemClickListener(MyItemClickListener listener){  
    this.mItemClickListener = listener;  
}  
 
//你想在什么时候触发此方法进行回调？
@Override  
public void onClick(View v) {  
    if(mListener != null){  
        mListener.onItemClick(v,getPosition());  
    }  
} 

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写太多的业务逻辑。

接口回调是指：可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调。看下面示例。

```java interface People{ void peopleList(); } class Student implements People{ public void peopleList(){ System.out.println("I’m a student.")； } } class Teacher implements People{ public void peopleList(){ System.out.println("I’m a teacher."); } } public class Example{ public static void main(String args[]){ People a; //声明接口变量 a=new Student(); //实例化，接口变量中存放对象的引用 a.peopleList(); //接口回调 a=new Teacher(); //实例化，接口变量中存放对象的引用 a.peopleList(); //接口回调 } } 结果： I’m a student. I’m a teacher. ```