（2.1.13）java的接口的使用和回调函数

【1】接口实现

【2】接口方法实现

package com.android.yunshi.dialog;
import com.android.yunshi.util.WSError;

import android.app.Activity;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.os.AsyncTask;
import android.widget.Toast;


//switcher到主界面间的“显示加载”的进度对话框的接口类，传递  显示进度条的成功和失败的文字


/*三种泛型类型分别代表“启动任务执行的输入参数”、“后台任务执行的进度”、“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。
1.execute(Params... params)，执行一个异步任务，需要我们在代码中调用此方法，触发异步任务的执行。
2.onPreExecute()，在execute(Params... params)被调用后立即执行，一般用来在执行后台任务前对UI做一些标记。
3.doInBackground(Params... params)，在onPreExecute()完成后立即执行，用于执行较为费时的操作，此方法将接收输入参数和返回计算结果。在执行过程中可以调用publishProgress(Progress... values)来更新进度信息。
4.onProgressUpdate(Progress... values)，在调用publishProgress(Progress... values)时，此方法被执行，直接将进度信息更新到UI组件上。
5.onPostExecute(Result result)，当后台操作结束时，此方法将会被调用，计算结果将做为参数传递到此方法中，直接将结果显示到UI组件上。*/
public abstract class LoadingDialog <Input,Result> extends AsyncTask<Input, WSError, Result>{

    private ProgressDialog mProgressDialog;
    protected Activity mActivity;
    private int mLoadingMsg;
    private int mFailMsg;

    public LoadingDialog(Activity activity, int loadingMsg, int failMsg){
        this.mActivity = activity;
        this.mLoadingMsg = loadingMsg;
        this.mFailMsg = failMsg;
    }

    @Override
    protected abstract Result doInBackground(Input... params);

    @Override
    protected void onCancelled() {

         failMsg();

        super.onCancelled();
    }

    @Override
    protected void onPreExecute() {
        String title = "";
        String message = mActivity.getString(mLoadingMsg);//获取登录mseeage索引的的文本内容
        mProgressDialog = ProgressDialog.show(mActivity, title, message, true, true, new OnCancelListener(){

            public void onCancel(DialogInterface dialog) {
                LoadingDialog.this.cancel(true);        
            }});
        super.onPreExecute();
    }

    @Override
    protected void onPostExecute(Result result) {

        if(result != null){
            doStuffWithResult(result);//自定义方法，在子类中实现
        } else {//未获取到数据则显示错误信息
            failMsg();//自定义方法
        }
        mProgressDialog.dismiss();//关闭进度对话框
        super.onPostExecute(result);
    }



    @Override
    protected void onProgressUpdate(WSError... values) {
        mProgressDialog.dismiss();
        Toast.makeText(mActivity, values[0].getMessage(), Toast.LENGTH_SHORT).show();
        this.cancel(true);
        super.onProgressUpdate(values);
    }

    public abstract void doStuffWithResult(Result result);

    protected void failMsg(){
        Toast.makeText(mActivity, mFailMsg, Toast.LENGTH_SHORT).show();
    }

    public void doCancel()
    {
        mProgressDialog.dismiss();
    }


}

//未登录的  获取  每日的  事宜 忌讳等
package com.android.yunshi.dialog;


import com.android.yunshi.api.impl.YunshiFunctions;
import com.android.yunshi.api.impl.YunshiGetApiImpl;
import com.android.yunshi.entity.DaliyYunChengEntity;
import com.android.yunshi.util.WSError;

import android.app.Activity;
import android.content.Intent;
import android.util.Log;
import android.widget.Toast;

public class GetDaliyYunChengDialog extends LoadingDialog<String[],DaliyYunChengEntity>{

    private Intent mIntent;
    public GetDaliyYunChengDialog(Activity activity, int loadingMsg, int failMsg,Intent intent) {
        super(activity, loadingMsg, failMsg);
        mIntent = intent;
    }

    @Override
    protected DaliyYunChengEntity doInBackground(String[]... params) {
        //YunshiConfiguration yunshiconfiguration = null;
        DaliyYunChengEntity entity = null;
        YunshiGetApiImpl  server = new YunshiGetApiImpl();
        String str[] = params[0];
        try {
            String string = server.GetDaliyYunChengData(mActivity, str[0]);

            Log.d("lilin", "string==" + string);
            entity = YunshiFunctions.ResolveDaliyYunChengString(string);
        } catch (WSError e) {
            e.printStackTrace();
        }       
        return entity;
    }

    @Override
    public void doStuffWithResult(DaliyYunChengEntity result) {
        if(result!=null){
            mIntent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
            mIntent.putExtra("DaliyYunChengEntity", result);
            mActivity.startActivity(mIntent);
/*          if(mActivity instanceof YunshiRegisterActivity){
                mActivity.finish();
             }*/
        } 
    }

}

【3】回调函数

回调函数（Callback Function）是怎样一种函数呢？
函数是用来被调用的，我们调用函数的方法有两种：
l 直接调用：在函数A的函数体里通过书写函数B的函数名来调用之，使内存中对应函数B的代码得以执行。这里，A称为“主叫函数”（Caller），B称为“被叫函数”（Callee）。
l 间接调用：在函数A的函数体里并不出现函数B的函数名，而是使用指向函数B的函数指针p来使内存中属于函数B的代码片断得以执行——听起来很酷，是吧。

比起直接调用来，间接调用的确麻烦，那为什么还要使用间接调用呢？原因很简单——直接调用把函数名都写进函数体了，经过编译器那么一编译，板上钉钉，A注定调用的是B了，这样的程序只能按照程序员事先设计好的流程执行下去，太呆板了。此时，间接调用的巨大灵活性就显现出来了。想一想，如果p是函数A的一个参数（参数是变量，是变量就可以变吗！），那么程序的最终用户完全可以通过操作来改变p的指向——这样，A在通过p调用函数的时候就有机会调用到不同的函数，这样程序的实用性和扩展性就强多了。

在JAVA中没有指针，怎么办？我们可以通过接口（interface）来实现定义回调函数。

所谓回调，就是客户程序CLIENT调用服务程序SERVER中的某个函数SA，然后SERVER又在某个时候反过来调用CLIENT中的某个函数CB，对于CLIENT来说，这个CB便叫做回调函数。

4 回调函数步骤

定义一个回调接口

public interface MyCallInterface {
    public void  printName();
}

定义一个类Caller，按照上面的定义就是程序员A写的程序a，这个类里面保存一个接口引用。 Server

public class Caller {
    private MyCallInterface callInterface;

    public Caller() {
    }

    public void setCallFunc(MyCallInterface callInterface) {
        this.callInterface = callInterface;
    }

    public void call() {//实现用户自定义输出，方法逻辑
        callInterface.printName();
    }
}

第三是定义程序员B写的程序b

public class Client implements MyCallInterface {

    @Override
    public void printName() {
        System.out.println("This is the client printName method");
    }
}

B写主函数

public class Test {
    public static void main(String[] args) {
        Caller caller = new Caller();
        caller.setCallFunc(new Client());
        caller.call();
    }
}

B在测试方法中直接使用匿名类，省去第3步。

public class Test {
    public static void main(String[] args) {
        Caller caller = new Caller();
//      caller.setCallFunc(new Client());
        caller.setCallFunc(new MyCallInterface() {
            public void printName() {
                System.out.println("This is the client printName method");
            }
        });
        caller.call();
    }
}