给个Java接口回调的例子

Posted 2023-05-16

如题，有代码最好。

接口回调是指：可以把使用某一接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调。
示例代码：
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. 参考技术A /**
* 回调接口
*/
interface TestTemplateCallBack
Object doSomething();
class Template2 /**
* 执行业务逻辑的方法，参数类型为接口对象
*
* @param callBack:TestTemplateCallBack接口对象
*/
public void execute(TestTemplateCallBack callBack)
try
System.out.println("事务开始。。。");
System.out.println("开始执行业务逻辑。。。");
callBack.doSomething();
System.out.println("业务逻辑执行成功，提交事务");
catch (Exception e)
System.out.println("出现错误，回滚");
e.printStackTrace();


public class TemplateTest2
public void insert(final String msg)
Template2 t = new Template2();
// 匿名内部类重写方法
t.execute(new TestTemplateCallBack()
public Object doSomething()
// 事务出错代码
// int i = 1 / 0;
System.out.println("插入数据:" + msg);
return null;

);
public static void main(String[] args)
TemplateTest2 t = new TemplateTest2();
t.insert("Hello");


在这里申明一个接口，里面有个方法doSomething()。Template2 这个类中的execute()方法用来执行事务，其中有个参数：execute(TestTemplateCallBack callBack)，参数类型为之前定义的接口对象，然后就可以利用这个对象来调用doSomething()方法。但是doSomething()方法具体的操作内容在哪呢？它在TemplateTest2的insert()方法里面，这里在TemplateTest2类中定义一个insert()方法，接着申明一个Template2对象t，当执行t.execute()方法的时候，这时我们写个匿名类来当传入参数，这匿名类就是之前的接口，在匿名类中重写doSomething()方法就可以实现具体操作了。实际的列子可以参考spring源码中的JdbcTemplate类。

JAVA回调机制和观察者模式实例分享

回调函数在JAVA中使用频繁，比如Swing可视化编码中的监听事件等等，一般回调函数都是，通过某一个方法的执行，自动调用回调对象的回调方法，比如，有一个接口，里面有一个方法onNotify()，这个方法是一个回调方法，表明当触发事件发生时候，该调用的方法，举个例子：

一个回调接口

/**
 *  @author minliangzhi
 *  @date 2016年9月8日
 */
public interface ICallBack {
    
    void onNotify();
}

一个具体的实体对象，会出发回调函数的执行：

/**
 *  @author minliangzhi
 *  @date 2016年9月8日
 */
public class Task {
    private ICallBack callBack;
    
    public Task(ICallBack callBack) {
        this.callBack = callBack;
    }
    
    public void doSomething() {
        callBack.onNotify();
    }
}

具体的使用方法为：

    public static void main(String[] args) {
        new Task(new ICallBack() {
            
            @Override
            public void onNotify() {
                System.out.println("我是回调方法");
            }
        }).doSomething();
    }

通过调用实体对象的方法，就会触发回调函数对象的回调方法，我们这里只是简单的使用了一个匿名类的方法提供了回调对象。

 

由此，我们可以分析下观察者模式的具体含义和一般实现：

观察者模式可以分成两部分，一部分是发布者，一部分是观察者，发布者的某些方法，会通知所有的观察者，让他们知晓发布者的发布信息。

观察者：

/**
 *  @author minliangzhi
 *  @date 2016年9月8日
 */
public interface Observer {

    void onNotify(String content);
}

public class Mike implements Observer {

    @Override
    public void onNotify(String content) {
        System.out.println("Mike get : " + content);
    }
}

public class Bob implements Observer {

    @Override
    public void onNotify(String content) {
        System.out.println("Bob get : " + content);
    }

}

上述定义了两个观察者，下面定义一个发布消息者：

/**
 *  @author minliangzhi
 *  @date 2016年9月8日
 */
public interface Publisher {

    /**
     * 注册一个观察者
     * @param observer
     */
    void registObserver(Observer observer);
    
    /**
     * 移除一个观察者
     * @param observer
     */
    void removeObserver(Observer observer);
    
    /**
     * 通知所有的观察者
     */
    void notifyAllObserver();
}

一个具体的实现类，工作发布者Hunter：

/**
 *  @author minliangzhi
 *  @date 2016年9月8日
 */
public class Hunter implements Publisher {

    private List<Observer> observer;
    
    private String jobContent;
    
    public void setJob(String content) {
        this.jobContent = content;
    }
    
    public Hunter() {
        this.observer = new ArrayList<Observer>();
    }

    @Override
    public void registObserver(Observer observer) {
        this.observer.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        this.observer.remove(observer);
    }

    @Override
    public void notifyAllObserver() {
        for(Observer ob : observer) {
            ob.onNotify(jobContent);
        }
    }
}

使用方法：

    public static void main(String[] args) {
        /** 构造发布者和观察者，并注册 */
        Hunter hunter = new Hunter();
        Observer bob = new Bob();
        Observer mike = new Mike();
        hunter.registObserver(bob);
        hunter.registObserver(mike);
        /** 发布消息，通知所有观察者 */
        hunter.setJob("JAVA");
        hunter.notifyAllObserver();
    }