精华内容
下载资源
问答
  • Android使用回调接口

    千次阅读 2017-01-07 11:21:57
    Android使用回调接口Android使用回调接口 adapter与context之间建立回调 adapter里面需要执行的操作 context里面需要执行的操作 源码如下adapter与context之间建立回调 adapter里面可触发一下按键事件,然后这个...

    Android使用回调接口

    adapter与context之间建立回调

    adapter里面可触发一下按键事件,然后这个按键事件必须在context进行响应,这里有一种处理方法就是使用接口回调,顾名思义,接口回调就是暴露自己的接口,让其他对象来实现自己的接口。这里就是adapter需要定义并暴露自己的接口,然后让context来实现自己的接口。

    adapter里面需要执行的操作

    • 首先adapter里面自定义一个接口,接口里面的方法自己定义,不需要方法的主体,只要有方法名字,方法形参,方法返回类型就可以了。例如下面:

      public interface ClickEvent{
          void add();
          void del(int position);
      }
    • 然后adapter里面需要定义一个接口(这里定义的接口不需要初始化,初始化工作交给context,这种说法也不正确),并在自己的点击事件里面调用接口里面的方法,例如下面:

        ClickEvent mClickEvent;
        //这里是为item里面的按钮设置点击事件,但是点击之后的事件具体怎么操作这里不需要知道,否者接口回调就没意义了。
        viewholder.addordel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                   if(((int)v.getTag())==2)//这里是为了区分此次点击事件到底执行添加还是删除操作
                    {
                        mClickEvent.add();
                        Log.i(TAG, "onClick: login");
                    }
                    else
                    {
                        mClickEvent.del(position);
                    }
                }
            });
    • adapter自己定义了在哪儿调用接口,但是并没有暴露这个接口,所以外面的context并找不到这个接口,所以这里写一个方法暴露接口,顺便初始化我们建立的 mClickEvent,例如下面:
        public void setClickEvent(ClickEvent event){
            mClickEvent=event;
        }

    context里面需要执行的操作

    • adapter里面需要暴露的接口已经有了,我们只需要在context调用并实现接口就行了,因为这里是使用的adapter,所以在context里面找到我们建立的adapter并调用里面的暴露接口方法这里就是上面的setClickEvent方法),例如下面:
        mReAdapter.setClickEvent(new AccountReAdapter.ClickEvent() {
                @Override
                public void add() {
                    mSsoHandler.authorize(new AuthListener());
                    Log.i(TAG, "add: callback");
                }
    
                @Override
                public void del(int position) {
                    mBeanList.remove(position);
                    mReAdapter.notifyDataSetChanged();
                    mAccessToken = new Oauth2AccessToken();
                }
            });

    源码如下:


    这里的源码是在项目中提取出来的,所以有些复杂。如果心情烦躁,可以不看。
    adapter代码

    package com.hskj.damnicomniplusvic.weiqian.adapter;
    import android.support.v7.widget.RecyclerView;
    import android.util.Log;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.Button;
    import android.widget.ImageView;
    import android.widget.TextView;
    import com.bumptech.glide.Glide;
    import com.hskj.damnicomniplusvic.weiqian.Bean.AccountBean;
    import com.hskj.damnicomniplusvic.weiqian.R;
    
    import java.util.List;
    
    import butterknife.Bind;
    import butterknife.ButterKnife;
    
    import static com.bumptech.glide.gifdecoder.GifHeaderParser.TAG;
    
    /**
     * Created by DAMNICOMNIPLUSVIC on 2017/1/4.
     */
    
    public class AccountReAdapter extends RecyclerView.Adapter  {
        List<AccountBean> mList;
        ClickEvent mClickEvent;
        @Override
        public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.account_recycle_item, parent, false);
            return new AccountViewholder(view);
        }
    
        @Override
        public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {
            AccountViewholder viewholder= (AccountViewholder) holder;
            AccountBean bean=mList.get(position);
            Glide.with(holder.itemView.getContext()).load(bean.getAvatar_large()).into(viewholder.headimg);
            viewholder.nickname.setText(bean.getScreen_name());
            if(bean.getScreen_name()!=null&&bean.getScreen_name()!="") {
                viewholder.addordel.setBackgroundResource(R.drawable.fensi);
                viewholder.addordel.setTag(1);
            }else
            {
                viewholder.addordel.setBackgroundResource(R.drawable.tianjia);
                viewholder.addordel.setTag(2);
            }
            viewholder.addordel.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                   if(((int)v.getTag())==2)
                    {
                        mClickEvent.add();
                        Log.i(TAG, "onClick: login");
                    }
                    else
                    {
                        mClickEvent.del(position);
                    }
                }
            });
        }
    
        public void setList(List<AccountBean> list){
            mList=list;
            notifyDataSetChanged();
        }
        @Override
        public int getItemCount() {
            return mList == null ? 0 : mList.size();
        }
    
        static class AccountViewholder extends RecyclerView.ViewHolder{
            @Bind(R.id.account_item_nickname)TextView nickname;
            @Bind(R.id.account_item_headimg)ImageView headimg;
            @Bind(R.id.account_item_add_del)Button addordel;
            public AccountViewholder(View itemView) {
                super(itemView);
                ButterKnife.bind(this,itemView);
            }
        }
    
        public interface ClickEvent{
            void add();
            void del(int position);
        }
        public void setClickEvent(ClickEvent event){
            mClickEvent=event;
        }
    }
    

    context代码:

    package com.hskj.damnicomniplusvic.weiqian.fragment;
    
    import android.app.Activity;
    import android.content.Intent;
    import android.os.Bundle;
    import android.support.annotation.Nullable;
    import android.support.v4.app.Fragment;
    import android.support.v7.widget.LinearLayoutManager;
    import android.support.v7.widget.RecyclerView;
    import android.text.TextUtils;
    import android.util.Log;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.TextView;
    import android.widget.Toast;
    
    import com.hskj.damnicomniplusvic.weiqian.Bean.AccountBean;
    import com.hskj.damnicomniplusvic.weiqian.R;
    import com.hskj.damnicomniplusvic.weiqian.adapter.AccountReAdapter;
    import com.hskj.damnicomniplusvic.weiqian.customview.RoundImageView;
    import com.hskj.damnicomniplusvic.weiqian.utils.Constant;
    import com.sina.weibo.sdk.auth.AuthInfo;
    import com.sina.weibo.sdk.auth.Oauth2AccessToken;
    import com.sina.weibo.sdk.auth.WeiboAuthListener;
    import com.sina.weibo.sdk.auth.sso.SsoHandler;
    import com.sina.weibo.sdk.exception.WeiboException;
    import com.sina.weibo.sdk.net.RequestListener;
    import com.sina.weibo.sdk.openapi.UsersAPI;
    import com.sina.weibo.sdk.openapi.models.ErrorInfo;
    import com.sina.weibo.sdk.openapi.models.User;
    import com.sina.weibo.sdk.utils.LogUtil;
    
    import java.util.ArrayList;
    import java.util.List;
    
    import butterknife.Bind;
    import butterknife.ButterKnife;
    
    
    public class AccountFragment extends Fragment {
        // TODO: Rename parameter arguments, choose names that match
    
        String TAG="AccountFragment";
        @Bind(R.id.account_description) TextView description;
        @Bind(R.id.account_fans) TextView fans;
        @Bind(R.id.account_favourite) TextView favourite;
        @Bind(R.id.account_follow) TextView follow;
        @Bind(R.id.account_gender) TextView gender;
        @Bind(R.id.account_headimage) RoundImageView headimage;
        @Bind(R.id.account_location) TextView location;
        @Bind(R.id.account_nickname) TextView nickname;
        @Bind(R.id.account_states) TextView states;
        @Bind(R.id.account_recycleview) RecyclerView mRecyclerView;
        private List<AccountBean> mBeanList;
        private AccountReAdapter mReAdapter;
        /** 封装了 "access_token","expires_in","refresh_token",并提供了他们的管理功能  */
        private Oauth2AccessToken mAccessToken;
        private AuthInfo mAuthInfo;
        /** 注意:SsoHandler 仅当 SDK 支持 SSO 时有效 */
        private SsoHandler mSsoHandler;
        private UsersAPI mUsersapi;
    
    
        public AccountFragment() {
            // Required empty public constructor
        }
    
    
        // TODO: Rename and change types and number of parameters
        public static AccountFragment newInstance() {
            AccountFragment fragment = new AccountFragment();
            return fragment;
        }
    
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
        }
    
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            // Inflate the layout for this fragment
            View view=inflater.inflate(R.layout.fragment_account, container, false);
            ButterKnife.bind(this,view);
            return view;
        }
    
        @Override
        public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
            super.onViewCreated(view, savedInstanceState);
            AccountBean footer=new AccountBean();
            footer.setScreen_name("");
            footer.setAvatar_large("");
            mBeanList=new ArrayList<>();
            mBeanList.add(footer);
            mReAdapter=new AccountReAdapter();
            mRecyclerView.setLayoutManager(new LinearLayoutManager(getContext()));
            mRecyclerView.setAdapter(mReAdapter);
            mReAdapter.setList(mBeanList);
            mReAdapter.setClickEvent(new AccountReAdapter.ClickEvent() {
                @Override
                public void add() {
                    mSsoHandler.authorize(new AuthListener());
                    Log.i(TAG, "add: callback");
                }
                @Override
                public void del(int position) {
                    mBeanList.remove(position);
                    mReAdapter.notifyDataSetChanged();
                    mAccessToken = new Oauth2AccessToken();
                }
            });
            // 创建微博实例
            //mWeiboAuth = new WeiboAuth(this, Constants.APP_KEY, Constants.REDIRECT_URL, Constants.SCOPE);
            // 快速授权时,请不要传入 SCOPE,否则可能会授权不成功
            mAuthInfo=new AuthInfo(this.getActivity(), Constant.APP_KEY,Constant.REDIRECT_URL,Constant.SCOPE);
            mSsoHandler = new SsoHandler(this.getActivity(), mAuthInfo);
        }
    
    
        /**
         * 当 SSO 授权 Activity 退出时,该函数被调用。
         *
         * @see {@link Activity#onActivityResult}
         */
        @Override
        public void onActivityResult(int requestCode, int resultCode, Intent data) {
            super.onActivityResult(requestCode, resultCode, data);
            Log.i(TAG, "onActivityResult: "+requestCode+"\tresultCode"+resultCode);
            // SSO 授权回调
            // 重要:发起 SSO 登陆的 Activity 必须重写 onActivityResults
            if (mSsoHandler != null) {
                mSsoHandler.authorizeCallBack(requestCode, resultCode, data);
            }
        }
    
        /**
         * 微博认证授权回调类。
         * 1. SSO 授权时,需要在 {@link #onActivityResult} 中调用 {@link SsoHandler#authorizeCallBack} 后,
         *    该回调才会被执行。
         * 2. 非 SSO 授权时,当授权结束后,该回调就会被执行。
         * 当授权成功后,请保存该 access_token、expires_in、uid 等信息到 SharedPreferences 中。
         */
        class AuthListener implements WeiboAuthListener {
            @Override
            public void onComplete(Bundle values) {
                // 从 Bundle 中解析 Token
                mAccessToken = Oauth2AccessToken.parseAccessToken(values);
                //从这里获取用户输入的 电话号码信息
                Log.i(TAG, "onComplete: "+mAccessToken);
                String  phoneNum =  mAccessToken.getPhoneNum();
                if (mAccessToken.isSessionValid()) {
                    // 显示 Token
                    mUsersapi=new UsersAPI(getContext(),Constant.APP_KEY,mAccessToken);
                    mUsersapi.show(mAccessToken.getUid(),mListener);
                    // 保存 Token 到 SharedPreferences
                    Toast.makeText(getContext(),
                            R.string.weibosdk_demo_toast_auth_success, Toast.LENGTH_SHORT).show();
                } else {
                    // 以下几种情况,您会收到 Code:
                    // 1. 当您未在平台上注册的应用程序的包名与签名时;
                    // 2. 当您注册的应用程序包名与签名不正确时;
                    // 3. 当您在平台上注册的包名和签名与您当前测试的应用的包名和签名不匹配时。
                    String code = values.getString("code");
                    String message = getString(R.string.weibosdk_demo_toast_auth_failed);
                    if (!TextUtils.isEmpty(code)) {
                        message = message + "\nObtained the code: " + code;
                    }
                    Toast.makeText(getContext(), message, Toast.LENGTH_LONG).show();
                    Log.i(TAG, "onComplete: "+message);
                }
            }
    
            @Override
            public void onCancel() {
                Toast.makeText(getContext(),
                        R.string.weibosdk_demo_toast_auth_canceled, Toast.LENGTH_LONG).show();
            }
    
            @Override
            public void onWeiboException(WeiboException e) {
                Toast.makeText(getContext(),
                        "Auth exception : " + e.getMessage(), Toast.LENGTH_LONG).show();
            }
        }
    
        /**
         * 微博 OpenAPI 回调接口。
         */
        private RequestListener mListener = new RequestListener() {
            @Override
            public void onComplete(String response) {
                Log.i(TAG, "onComplete: "+response);
                if (!TextUtils.isEmpty(response)) {
                    // 调用 User#parse 将JSON串解析成User对象
                    User user = User.parse(response);
                    if (user != null) {
                        Toast.makeText(getContext(),
                                "获取User信息成功,用户昵称:" + user.screen_name,
                                Toast.LENGTH_LONG).show();
                    } else {
                        Toast.makeText(getContext(), response, Toast.LENGTH_LONG).show();
                    }
                }
            }
    
            @Override
            public void onWeiboException(WeiboException e) {
                LogUtil.e(TAG, e.getMessage());
                ErrorInfo info = ErrorInfo.parse(e.getMessage());
                Toast.makeText(getContext(), info.toString(), Toast.LENGTH_LONG).show();
            }
        };
    }
    
    展开全文
  • 回调接口在完成某些特殊的功能时还是蛮有用的,下面为大家分享下具体的使用方法,感兴趣的朋友可以参考下哈
  • android接口回调

    2016-03-09 19:18:02
    android接口回调
  • android 万能回调接口

    2015-08-19 17:36:43
    刚做android开发时经常遇到数据传递的问题,因为对Java也不是很熟悉,...简单的万能回调接口,自己感觉还不错。自己是个新手,欢迎各种菜鸟、小牛、大牛吐槽和指导! 1、先写个所以接口回调的都继承的BaseHandle

    <span style="font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);">刚做android开发时经常遇到数据传递的问题,因为对Java也不是很熟悉,传递数据通过Intent或直接放到一个静态类中。</span>

    后来才知道通过java接口回调来传输数据和做各种监听,后来看到Event Bus数据传输的框架受到了启发,自己弄了一个

    简单的万能回调接口,自己感觉还不错。自己是个新手,欢迎各种菜鸟、小牛、大牛吐槽和指导!


    1、先写个所以接口回调的都继承的BaseHandle

    public abstract interface BaseHandle {
    
    }

    2、在写个管理所以接口回调的类

    public class HandlerRegister {
    	
    	private static HashMap<String, ArrayList<BaseHandle>> receiverPond = new HashMap<String, ArrayList<BaseHandle>>();
    	
    
    	
    	/**
    	 * 注册新的handle
    	 * @param handleName
    	 */
    	public static void addType(String handleName) {
    		try {
    			ArrayList<BaseHandle> itemList = new ArrayList<BaseHandle>();
    			receiverPond.put(handleName, itemList);
    		} catch (Exception e) {
    			e.printStackTrace(); 
    		}
    	}
    	
    	/**
    	 * 添加 handle
    	 * @param key
    	 * @param handle
    	 */
    	public static void setReceiver(String key,BaseHandle handle) {
    		
    		try {
    			if (receiverPond.containsKey(key)) {
    				receiverPond.get(key).add(handle);
    			}else {
    				addType(key);
    				receiverPond.get(key).add(handle);
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		
    	}
    	
    	/**
    	 * 获取已经存在的handle
    	 * @param key
    	 * @return
    	 */
    	public static ArrayList<BaseHandle> getReceiver(String key) {
    		return receiverPond.get(key);
    	}
    	
    	/**
    	 * 删除单个handle
    	 * @param key
    	 * @param handle
    	 */
    	public static void deleteHandle(String key,BaseHandle handle) {
    		try {
    			if (!receiverPond.containsKey(key)) {
    				return;
    			}
    			receiverPond.get(key).remove(handle);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		
    	}
    	
    	/**
    	 * 删除key下所有handle
    	 * @param key
    	 */
    	public static void deleteAllHandle(String key) {
    		try {
    			receiverPond.remove(key);
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }

    3、根据自己需要的传递的数据去创建回调接口并继承BaseHandle

    public interface BuyServiceHandle extends BaseHandle{
    	public static final String BUYSERVICE_HANDLE_KEY = "buyservice_handle";
    	public void buyResult(String uid);
    
    }
    4、注册回调接口,谁使用谁注册

    	BuyServiceHandle mBuyServiceHandle = new BuyServiceHandle() {
    		
    		@Override
    		public void buyResult(final String uid) {			
    			updateDoctor(uid);	
    			
    		}
    
    
    	};
    HandleRegister.setReceiver(BuyServiceHandle.BUYSERVICE_HANDLE_KEY, mBuyServiceHandle);

    5、发送数据

    	private void informUpdateDoctorList(String uid) {
    		ArrayList<BaseHandle> handleList = HandleRegister.getReceiver(BuyServiceHandle.BUYSERVICE_HANDLE_KEY);
    		if (handleList == null) {
    			return;
    		}
    		for (BaseHandle temp:handleList) {
    			((BuyServiceHandle)temp).buyResult(uid);
    		}
    	}






    展开全文
  • Android里面最常用的回调接口的一个实例,并不是什么很厉害的东西,只是为了加深对回调的用法
  • Android开发中我们很多地方都用到了方法的回调回调就是把方法的定义和功能导入实现分开的一种机制,目的是为了解耦他的本质是基于观察者设计模式,即观察者设计模式的的简化版,例如:在下载时候的进度回调,在...
  • Android Adapter回调接口

    千次阅读 2015-04-17 14:58:13
    Andoird中当activity中需要处理adapter中listview的item点击事件,这时候需要用到回调接口,Adapter中定义的接口相当与发布,在activity中实现相当于是响应。  这样activity中便可以获取adapter中的数据: ①回调...

       Andoird中当activity中需要处理adapter中listview的item点击事件,这时候需要用到回调接口,Adapter中定义的接口相当于发布,在activity中实现相当于是响应。

     这样activity中便可以获取adapter中的数据:
    ①回调接口可以把adapter中处理过的数据传给activity。
    ②Activity中获取item中数据可以直接用 adapter.getItem(position)获取,也可以直接在activity获取到的数据中获取。
    下面是代码:
    Adapter中:
    @Override
     public View getView(int position, View convertView, ViewGroup parent) {
      final ViewHolder viewHolder;
      if (convertView == null) {
       convertView.setTag(viewHolder);
      } else {
       viewHolder = (ViewHolder) convertView.getTag();
      }
    boolean subscribed = subscribed(item.userId);
     setAction(ItemHolder.action_button, position,!subscribed);
      return convertView;
     }
     
     private void setAction(final View view,final int position,final boolean add) {
      view.setOnClickListener(new OnClickListener() {
       @Override
       public void onClick(View v) {
        if(onItemAddClick != null) {
         onItemAddClick.onItemClick(position,add);
        }
       }
      });
     }
     
     public static interface OnAddClickListener {
      // true add; false cancel
      public void onItemClick(int position,boolean add); //传递boolean类型数据给activity
     }
     
     // add click callback
     OnAddClickListener onItemAddClick;
    
     public void setOnAddClickListener(OnAddClickListener onItemAddClick) {
      this.onItemAddClick = onItemAddClick;
     } 

    Activity中:

     AddSubscribeAdapter adapter = new AddSubscribeAdapter(mActivity, cacheHelper);
      adapter.setOnAddClickListener(onItemActionClick);
      mPullRefreshListView.setAdapter(adapter);
    
    OnAddClickListener onItemActionClick = new OnAddClickListener() {
     
      @Override
      public void onItemClick(int position,boolean add) {
       final LiveHallInfoEntity item = adapter.getItem(position);
       if (add) { //接受Adapter传过来的数据进行操作
        addSubscribe(item);
       } else {
        cancelSubscribe(item);
       }
      }
     };
    

    这样当点击item时,可以把数据传入activity,activity可以进行相应的操作。

    展开全文
  • android 接口回调

    2016-05-31 17:53:56
    一个演示android接口回调的demo
  • Android 回调接口是啥,回调机制详解

    万次阅读 多人点赞 2015-07-16 22:45:27
    首先解决啥是回调: 举个例子:某天,我打电话向你请教问题,当然是个难题,你一时想不出解决方法,我又不能拿着电话在那里傻等,于是我们约定:等你想出办法后打手机通知我,这样,我就挂掉电话办其它事情去了。过...

    首先解决啥是回调:

    举个例子:某天,我打电话向你请教问题,当然是个难题,你一时想不出解决方法,我又不能拿着电话在那里傻等,于是我们约定:等你想出办法后打手机通知我,这样,我就挂掉电话办其它事情去了。过了XX分钟,我的手机响了,你兴高采烈的说问题已经搞定,应该如此这般处理。


    C不会自己调用b,C提供b的目的就是让S来调用它,而且C不得不提供。S并不知道C提供的b是什么,因此S会约定b的接口规范(函数原型),然后由C提前通过S的一个函数r告诉S自己将要使用b函数(即注册)。r为注册函数。

    简单来说:回调函数就是预留给系统调用的函数,而且我们往往知道该函数被调用的时机,那我们继续完善下上面的那幅图。


    看着这幅图,其实我们回想一下,会发现,生活中到处都有回调这种思想存在。软件的很多思想其实只是我们实际生活中思维方式的一种转化。

    我们平时考试答题的第一件事是干嘛?没错,是写上学号和姓名。这里注意了,我们填写学号和姓名不是给自己看的(即该方法不是给自己调用的),而是给老师登记分数时看的(预留给系统将来调用),这其实就是一个回调的应用。老师提供接口(输入姓名,学号规则),我们利用接口注册。


    看到上面的小示例,大家对回调就有了一些了解了,我们再回到文章刚开始的例子。
    那个例子说明了“异步+回调”的编程模式。其中,你后来打手机告诉我结果便是一个“回调”过程;我的手机号码必须在以前告诉你,这便是注册回调函数;我的手机号码应该有效并且手机能够接收到你的呼叫,这是回调函数必须符合接口规范。


    我们已经大概知道了回调的基本流程,下面,来看看Android中回调的基本使用。

    场景一:

    Button button = (Button)this.findViewById(R.id.button);  
    button.setOnClickListener(newButton.OnClickListener() {  
       //回调函数  
       @override  
       publicvoidonClick(View v) {  
          buttonTextView.setText("按钮被点击了");  
       }  
    });  


    上面的代码给按钮加了一个事件监听器,这其实就是“回调”最常见的应用场景之一。我们自己不会显式地去调用onClick方法。用户触发了该按钮的点击事件后,它会由Android系统来自动调用。

    场景二:

    @Override  
    publicvoidonCreate(BundlesaveInstanceState) {  
       super.onCreate(saveInstanceState);  
       // You code...  
    }  
    @Override  
    publicvoidonResume() {  
       super.onResume();  
       // You code...  
    }  


    Activity的整个生命周期基本上都说回调函数在发挥作用。

    看了两个我们经常使用的回调方式,我们先来总结下android利用回调的基本方法。其实,只是把我们的那张图翻译了下。


    --你类--

    package lin.callback.test;
     
    public class You implements Runnable{
     
         
        private String who;
         private ContactInterface callBack;  
         public You() {
                // TODO Auto-generated constructor stub
         }
          
        //调用此方法就表示有人联系你了,注册到你这来
         public void setCallBack(String who,String question,ContactInterface callBack) {
             this.who = who;    
             System.out.println("你说:当前联系到我的人是"+who+",问题是"+question);
             this.callBack =callBack;
         }
            
         public void handleThings(){
             //假如你现在正在想问题的答案,需要一点时间
             for(int i=0;i<100000;i++){  
                   if(i == 0){
                       System.out.println("你正在思考问题.....");
                   }
             }
              
             String answer = "答案是A";
             //想到问题的办法了
             System.out.println("你说:想到答案了,准备打回去给"+who+"告诉他答案");
             callBack.callBackByTel(answer);
         }
     
        /* (non-Javadoc)
         * @see java.lang.Runnable#run()
         */
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                handleThings();
            } catch (Exception e) {
                e.printStackTrace();
            }
        } 
    }


    --我类--

    public class Me {
     
         public static void main(String[] args){  
              
             Me me = new Me();
             me.hasQuestion();
              
         }
          
         private void hasQuestion(){
             //现在有问题想不出来答案,想去问你
             You you = new You();
             you.setCallBack("蜗牛", "某道题答案是什么?", new ContactInterface() {
                 
                @Override
                public void callBackByTel(String answer) {
                    System.out.println("我说:嗯,好的,我收到答案了:"+answer+",谢谢");
                     
                }
            });
            //你接到电话,起床开始思考问题
            new Thread(you).start();
         }
    }


    --接口类(规范)--

    public interface ContactInterface {
         
        public void callBackByTel(String answer);
         
    }
    验证结果:
    你说:当前联系到我的人是蜗牛,问题是某道题答案是什么?
    你正在思考问题
    你说:想到问题了,准备打回去给蜗牛告诉他答案
    我说:嗯,好的,我收到答案了:答案是A,谢谢


    对回调的深入思考:

    程序的本质就是代码跳转,不管同步异步反射接口虚函数,本质上都是函数调用。函数我们要调用它,就需要它的指针,不同语言通过不同的方式来得到这个指针。而我们定义的接口其实就是一个函数指针,那么那个注册过程,其实就是相当于对那个函数指针赋值。通过这个函数指针来调用我们定义的自实现函数。




    展开全文
  • Android接口回调

    2017-11-09 14:49:46
    常见接口回调的三种方式,可以根据博客一起同步学习。
  • Android接口回调Demo

    2018-04-09 14:48:18
    简单、易理解、实用的接口回调demo,适合初学者对接口回调学习和使用。
  • 安卓接口回调

    2017-11-05 17:42:51
    安卓接口回调是十分常见的一种传值的方式。 在这里简单的记录一下自己对接口回调的理解和用法。 第一次应用接口回调是应用在MVP框架模式中的M层获取数据,并且将数据回调给P层,下面贴一下我自己的代码。首先...
  • Android中基于回调接口的确权机制.pdf
  • Android中到处可见接口回调机制,尤其是UI事件处理方面,本文给大家介绍android接口回调机制,涉及到android接口回调相关知识,对本文感兴趣的朋友可以参考下本
  • 安智充值回调接口

    2014-01-16 18:24:27
    android平台,手游,安智手游充值回调接口部分源码
  • Android 自定义回调接口 博主小白,此篇文章为了加深自己对回调接口的印象 另外也为巩固已有的知识 第一步回调接口 接口名字随便命名 自己清楚意思就可以了 可以回调点击监听 长按监听 拖动监听 public ...
  • Android 接口回调实例

    千次阅读 2015-05-14 14:42:35
    Android接口回调方法处处涉及到,比如常用的Button点击事件就是一个接口回调,可见掌握熟练使用接口回调方法的重要性。 接口回调的简单解释就是:比如我这个类实现了一个接口里的方法doSomething,然后注册到你这里...
  • Android回调接口的写法

    千次阅读 2017-02-08 11:15:45
    * 删除的回调接口 */ //创建接口 public interface OnDeleteListener{ void delete(Node node, int position); } //声明接口对象 private OnDeleteListener mOnDeleteListener; //设置监听器,实例化...
  • android自定义回调接口

    千次阅读 2015-08-09 10:51:25
    这是流传已久的故事: 某天,我打电话向你请教问题,当然是个难题,你一时想不出解决方法,我又不...初学者,这篇文章,第一次理解自定义回调接口,可以说这是写给自己看的。。。 直接上码 一个自定义的View:
  • android kotlin 接口回调

    千次阅读 2018-08-27 16:40:02
    kotlin 接口回调的要相对于java有太多的代码简洁写 这也是新语言的优势 让语言越来越人性化简单化 在这里java的接口回调就不书写了 直接上kotlin 创建一个我们想要的回调 class MyCallBack { lateinit var ...
  • 接口回调

    2016-08-26 23:03:35
    什么是接口回调接口回调其本质与向上转型是一样的,不同的是:接口回调是利用接口句柄来得到并调用实现这个接口的子类引用;而向上转型则是用父类的句柄来得到并调用继承此类的子类的引用。接口回调,强调使用接口来...
  • Android回调接口使用实例

    千次阅读 2014-03-10 15:28:19
    MainActivity如下: package cc.cn; import cc.cn.ThreadSubclass.YourListener; import android.app.Activity; import android.os.Bundle;... * Android回调接口使用实例 */ public class MainActivity exten
  • 安卓接口回调原理

    2015-03-23 09:25:02
    在使用接口回调的时候发现了一个经常犯的错误,就是回调函数里面的实现有可能是用多线程或者是异步任务去做的,这就会导致我们期望函数回调完毕去返回一个主函数的结果,实际发现是行不通的,因为如果回调是多线程的...
  • Android 自定义接口回调

    千次阅读 2018-10-23 14:13:55
    1.定义一个简单的接口回调 下面是定义一个简单的接口,实现的功能是,设置名字爱好,并且返回给主 Activity。 1.1 自定义一个接口  定义一个名字为 setNameListener() 的接口类: /** * author: wu * date: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 120,488
精华内容 48,195
关键字:

回调接口安卓