接口回调（重点是理解）

模板性代码：

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