Question

我有以下界面：

public interface NumberOfCellsListener {
    public void numberOfCellsChanged(int patientId, int numOfCells);
}

public interface NumberOfCells {
    public void register(NumberOfCellsListener listener);
    public int numOfCells(int patientId);
}

public interface ProbabilityOfCancer {
    //this may be a time consuming calculation
    public double probability(int patientId, int numOfCells, bool gender, double weight);
}

这是我的癌症概率计算器的结构。我的任务是实现这一点，以便由于计算的耗时性而可以异步调用它。我是Java的新手，有人可以指导我如何实现这些接口吗？我不确定结构，即去哪里。我想我应该从numberOfCellsChanged的实现中的方法NumberOfCellsListener获取新的单元格数量。但是由于这是一个无效方法，所以我不确定该怎么办。

Answer 1

请尝试以下内容，以了解Java中的异步回调。您可以找到更多的教程和解释here

    // Java program to illustrate Asynchronous callback 

interface OnGeekEventListener { 

    // this can be any type of method 
    void onGeekEvent(); 
} 

class B { 

    private OnGeekEventListener mListener; // listener field 

    // setting the listener 
    public void registerOnGeekEventListener(OnGeekEventListener mListener) 
    { 
        this.mListener = mListener; 
    } 

    // My Asynchronous task 
    public void doGeekStuff() 
    { 

        // An Async task always executes in new thread 
        new Thread(new Runnable() { 
            public void run() 
            { 

                // perform any operation 
                System.out.println("Performing operation in Asynchronous Task"); 

                // check if listener is registered. 
                if (mListener != null) { 

                    // invoke the callback method of class A 
                    mListener.onGeekEvent(); 
                } 
            } 
        }).start(); 
    } 

    // Driver Program 
    public static void main(String[] args) 
    { 

        B obj = new B(); 
        OnGeekEventListener mListener = new A(); 
        obj.registerOnGeekEventListener(mListener); 
        obj.doGeekStuff(); 
    } 
} 

class A implements OnGeekEventListener { 

    @Override
    public void onGeekEvent() 
    { 
        System.out.println("Performing callback after Asynchronous Task"); 
        // perform some routine operation 
    } 
    // some class A methods 
}

Answer 2

不返回内容的接口方法通常具有更改内部状态或使用其他某种输出方式的功能（例如，将内容打印到控制台，通过网络发送内容或将其保存到数据库或文件。）

对于特定的接口：

与Listener中的NumberOfCellsListener一起使用的对象是安装（“注册”）的对象，该对象会在发生特定事件的情况下调用侦听器的方法。在您的情况下，基于接口名称，我假设当某些对象的单元格数量发生更改时，将调用您的方法。因此，您的问题应该是，到那时该信息需要您做什么，并在方法中完成。
实现NumberOfCells的类应该使上述语句正确。它具有register方法，该方法应将侦听器置于某种集合中（例如List-例如ArrayList？），然后在发生特定事件时，调用所有列表的监听者的numberOfCellsChanged方法。

因此，示例实现可能是：

public class NumberOfCellsPrinter implements NumberOfCellsListener {
    public void numberOfCellsChanged(int patientId, int numOfCells) {
        System.out.println("The number of cells for parentId:" + parentId + " has changed to " + numOfCells + ".");
    }
}

...

public class PetriDish implements NumberOfCells {
    private ArrayList<NumberOfCellsListener> listeners = new ArrayList<>();
    private int numOfCells = 0;

    public void register(NumberOfCellsListener listener) {
        if (listener != null && !listeners.contains(listener)) {
            listeners.add(listener);
        }
    }

    public int numOfCells(int patientId) {
        for (NumberOfCellsListener listener : listeners) {
            listener.numberOfCellsChanged(parentId, numOfCells);
        }
        return numOfCells;
    }
}

尽管此示例完全没有意义，并且始终将0生成为numOfCells，但它应演示侦听器的概念。

非常重要的是，您要熟悉并行性的风险和陷阱，因为这是实现目标的关键因素。

异步回调和监听器

2 个答案: