锐客网

  1. 首页 > 睿知 > it技术 > >

安卓回调java代码 android 基于回调的事件处理

IT技术回调

请问糊朋们什么是Java回调方法？具体的讲述些 。给我举个JAVA小程序例子也可以所谓回调，就是客户程序C调用服务程序S中的某个函数A ， 然后S又在某个时候反过来调用C中的某个函数B，对于C来说，这个B便叫做回调函数 。
用DOM4J写解析xml文档的例子
如下:
【安卓回调java代码 android 基于回调的事件处理】SAXReader sax = new SAXReader();
String file = this.getServletContext().getRealPath("/xml/news.xml");//获得xml文档的路径
Document doc = sax.read(file);
//获得根元素坐标
Element root = doc.getRootElement();
String valuehttps://www.04ip.com/post/= "";
List nodes = root.selectNodes("//new");
//得到元素个数
int size = nodes.size();
//定位到最后一个元素
Element el = (Element) nodes.get(size - 1);
//得到该元素所有属性集合
Iterator it = el.attributeIterator();
//循环遍历
while (it.hasNext()) {
//将集合中包含的元素转换为Attribute类型
Attribute att = (Attribute) it.next();
//取出里面的数值
value = https://www.04ip.com/post/att.getValue();
}
这样 所有的值就能都取出来了
不过 要导入这几个包包
org.dom4j.*
org.dom4j.io.*
java.util.*
java.io.*
java中怎样定义回调函数程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序 。程序员B要让a调用自己的程序b中的一个方法，于是，他通过a中的接口回调自己b中的方法 。目的达到 。在C/C中，要用回调函数 ， 被掉函数需要告诉调用者自己的指针地址，但在JAVA中没有指针 ， 怎么办？我们可以通过接口（interface）来实现定义回调函数 。
假设我是程序员A，以下是我的程序a：
[java] view plaincopyprint?
public class Caller
{
public MyCallInterface mc;
public void setCallfuc(MyCallInterface mc)
{
this.mc= mc;
}
public void call(){
this.mc.method();
}
}
还需要定义一个接口，以便程序员B根据我的定义编写程序实现接口 。
public interface MyCallInterface
{
public void method();
}
于是 ， 程序员B只需要实现这个接口就能达到回调的目的了：
public class B implements MyCallInterface
{
public void method()
{
System.out.println("回调");
}
public static void main(String args[])
{
Caller call = new Caller();
call.setCallfuc(new B());
call.call();
}
}
android onclicklistener是java函数回调机制吗很多时候，对某个控件实现点击事件的监听，会像下面这样做：
Button btn = new Button(this);
btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// doSth
}
});
按照上面所说的，可以调用接口的方法 ， 但是接口需要一个具体的实现，所以应该知道，setOnClickListener中的参数应该是一个接口
public interface OnClickListener {
/**
* Called when a view has been clicked.
*
* @param v The view that was clicked.
*/
void onClick(View v);
}
接口中还有一个onClick方法 。既然是回调，再看看这个方法在哪里被调用了
先看setOnClickListener方法
public void setOnClickListener(@Nullable OnClickListener l) {
if (!isClickable()) {
setClickable(true);
}
getListenerInfo().mOnClickListener = l;
}
关键是把OnClickListener的对象赋值给了ListenerInfo的mOnClickListener，再看下去
public boolean performClick() {
final boolean result;
final ListenerInfo li = mListenerInfo;
if (li != nullli.mOnClickListener != null) {
playSoundEffect(SoundEffectConstants.CLICK);
li.mOnClickListener.onClick(this);
result = true;
} else {
result = false;
}
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);
return result;
}
看到在这个叫做performClick的方法中调用了onClick方法，还有另外一个叫做callOnClick的方法也会调用onClick ， 区别可以去看看源码的说明 ， 这里不详细 。其实都是在屏幕接收到点击信号的时候，把数据一层一层的往上传递给framework，由framework来调用 。对于了解回调要明白的一点就是，在这个类中，调用的是接口的方法 。就是让编译器知道，调用接口方法的时候，去回调设置的OnClickListener子类的对应方法 。
java设计模式-回调、事件监听器、观察者模式转自()
背景
关于设计模式，之前笔者写过工厂模式，最近在使用gava ListenableFuture时发现事件监听模型特别有意思，于是就把事件监听、观察者之间比较了一番，发现这是一个非常重要的设计模式，在很多框架里扮演关键的作用 。
回调函数
为什么首先会讲回调函数呢？因为这个是理解监听器、观察者模式的关键 。
什么是回调函数
所谓的回调，用于回调的函数 。回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数 。有这么一句通俗的定义：就是程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序 。程序员B要让a调用自己的程序b中的一个方法，于是，他通过a中的接口回调自己b中的方法 。
举个例子：
这里有两个实体：回调抽象接口、回调者（即程序a）
回调接口（ICallBack ）
public interface ICallBack {
public void callBack();
}
回调者（用于调用回调函数的类）
public class Caller {
}
回调测试：
public static void main(String[] args) {
Caller call = new Caller();
call.call(new ICallBack(){
控制台输出：
start...
终于回调成功了！
end...
还有一种写法
或实现这个ICallBack接口类
class CallBackC implements ICallBack{
@Override
public void callBack() {
System.out.println("终于回调成功了！");
}
}
有没有发现这个模型和执行一个线程，Thread很像 。没错 ， Thread就是回调者，Runnable就是一个回调接口 。
new Thread(new Runnable(){
@Override
public void run() {
System.out.println("回调一个新线程！");
}}).start();
Callable也是一个回调接口 ， 原来一直在用 。接下来我们开始讲事件监听器
事件监听模式
什么是事件监听器
监听器将监听自己感兴趣的事件一旦该事件被触发或改变，立即得到通知，做出响应 。例如：android程序中的Button事件 。
java的事件监听机制可概括为3点：
java的事件监听机制涉及到 事件源，事件监听器，事件对象 三个组件,监听器一般是接口 ， 用来约定调用方式
当事件源对象上发生操作时，它将会调用事件监听器的一个方法，并在调用该方法时传递事件对象过去
事件监听器实现类,通常是由开发人员编写，开发人员通过事件对象拿到事件源，从而对事件源上的操作进行处理
举个例子
这里我为了方便，直接使用jdk，EventListener 监听器 ， 感兴趣的可以去研究下源码，非常简单 。
监听器接口
public interface EventListener extends java.util.EventListener {
//事件处理
public void handleEvent(EventObject event);
}
事件对象
public class EventObject extends java.util.EventObject{
private static final long serialVersionUID = 1L;
public EventObject(Object source){
super(source);
}
public void doEvent(){
System.out.println("通知一个事件源 source :"this.getSource());
}
}
事件源
事件源是事件对象的入口，包含监听器的注册、撤销、通知
public class EventSource {
//监听器列表，监听器的注册则加入此列表
private VectorEventListener ListenerList = new VectorEventListener();
//注册监听器
public void addListener(EventListener eventListener){
ListenerList.add(eventListener);
}
//撤销注册
public void removeListener(EventListener eventListener){
ListenerList.remove(eventListener);
}
//接受外部事件
public void notifyListenerEvents(EventObject event){
for(EventListener eventListener:ListenerList){
eventListener.handleEvent(event);
}
}
}
测试执行
public static void main(String[] args) {
EventSource eventSource = new EventSource();
}
控制台显示：
通知一个事件源 source :openWindows
通知一个事件源 source :openWindows
doOpen something...
到这里你应该非常清楚的了解 ， 什么是事件监听器模式了吧 。那么哪里是回调接口，哪里是回调者，对！EventListener是一个回调接口类 ， handleEvent是一个回调函数接口，通过回调模型，EventSource 事件源便可回调具体监听器动作 。
有了了解后，这里还可以做一些变动 。对特定的事件提供特定的关注方法和事件触发
public class EventSource {
...
public void onCloseWindows(EventListener eventListener){
System.out.println("关注关闭窗口事件");
ListenerList.add(eventListener);
}
}
public static void main(String[] args) {
EventSource windows = new EventSource();
/**
* 另一种实现方式
*/
//关注关闭事件，实现回调接口
windows.onCloseWindows(new EventListener(){
}
这种就类似于，我们的窗口程序，Button监听器了 。我们还可以为单击、双击事件定制监听器 。
观察者模式
什么是观察者模式
观察者模式其实原理和监听器是一样的，使用的关键在搞清楚什么是观察者、什么是被观察者 。
观察者(Observer)相当于事件监器 。有个微博模型比较好理解，A用户关注B用户，则A是B的观察者，B是一个被观察者，一旦B发表任何言论 ， A便可以获得 。
被观察者(Observable)相当于事件源和事件，执行事件源通知逻辑时 ， 将会回调observer的回调方法update 。
举个例子
为了方便，同样我直接使用jdk自带的Observer 。
一个观察者
public class WatcherDemo implements Observer {
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("openWindows")){
System.out.println("已经打开窗口");
}
}
}
被观察者
Observable 是jdk自带的被观察者 ， 具体可以自行看源码和之前的监听器事件源类似 。
主要方法有
addObserver() 添加观察者，与监听器模式类似
notifyObservers() 通知所有观察者
类Watched.java的实现描述：被观察者 ， 相当于事件监听的事件源和事件对象 。又理解为订阅的对象 主要职责：注册/撤销观察者（监听器），接收主题对象（事件对象）传递给观察者（监听器），具体由感兴趣的观察者（监听器）执行
/**
}
测试执行
public static void main(String[] args) {
Watched watched = new Watched();
WatcherDemo watcherDemo = new WatcherDemo();
watched.addObserver(watcherDemo);
watched.addObserver(new Observer(){
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("closeWindows")){
System.out.println("已经关闭窗口");
}
}
});
//触发打开窗口事件，通知观察者
watched.notifyObservers("openWindows");
//触发关闭窗口事件，通知观察者
watched.notifyObservers("closeWindows");
控制台输出：
已经打开窗口
已经关闭窗口
总结
从整个实现和调用过程来看 ， 观察者和监听器模式基本一样 。
有兴趣的你可以基于这个模型，实现一个简单微博加关注和取消的功能 。说到底，就是事件驱动模型，将调用者和被调用者通过一个链表、回调函数来解耦掉，相互独立 。
“你别来找我，有了我会找你” 。
整个设计模式的初衷也就是要做到低耦合，低依赖 。
再延伸下，消息中间件是什么一个模型？ 将生产者 服务中心（事件源）和消费者（监听器）通过消息队列解耦掉. 消息这相当于具体的事件对象，只是存储在一个队列里（有消峰填谷的作用） ， 服务中心回调消费者接口通过拉或取的模型响应 。想必基于这个模型，实现一个简单的消息中间件也是可以的 。
还比如gava ListenableFuture，采用监听器模式就解决了future.get()一直阻塞等待返回结果的问题 。
有兴趣的同学，可以再思考下观察者和责任链之间的关系，我是这样看的 。
同样会存在一个链表，被观察者会通知所有观察者，观察者自行处理，观察者之间互不影响 。而责任链，讲究的是击鼓传花 ， 也就是每一个节点只需记录继任节点，由当前节点决定是否往下传 。常用于工作流 ， 过滤器web filter 。
给个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.
关于安卓回调java代码和android 基于回调的事件处理的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息 ， 记得收藏关注本站 。

    推荐阅读


    上一篇：如何搭建花生壳服务器？ 花生壳服务器怎么搭建

    下一篇：如何提高服务器流量占用率？ 怎么样占服务器流量最大