简单Java回调不起作用 接口可调用接口 { void callBackMethod（）； } 班主任 { public static ArrayList names=new ArrayList（）； 静态定时器t=新定时器（）； public void addToList（字符串newAdd，CallableInterface回调） { 名称。添加（“宝马”）； 名称。添加（“道奇”）； t、 附表（新TimerTask（）{ @凌驾 public void run（）{ name.add（newAdd）； } }, 5000); callback.callBackMethod（）； } 公共作废打印列表（）{ System.out.println（Worker.names）； } } 类Boss实现CallableInterface { 工人w1=新工人（）； 公共老板（我） { w1.地址列表（卡纳姆，本）； } public void callBackMethod（） { w1.打印列表（）； } } 公共类回调 { 公共静态void main（字符串[]args） { Boss b=新Boss（“梅赛德斯”）； } }

我正在使用计时器模拟网络延迟。其想法是等待计时器完成（在本例中为5秒），然后打印arrayList。无论我对代码做了什么，我总是只得到[宝马，道奇]

应该是[宝马，道奇，奔驰]

---

我遗漏了什么？

Worker:：addToList

在调度计时器后立即调用

Boss:：callBackMethod

。这将打印当前只有2个元素的列表~4.99秒后，最后一个元素被添加到列表中，但它已经被打印出来了

如果只想在添加第3个元素后打印列表，请将回调调用移动到添加该元素后：

interface CallableInterface
{
    void callBackMethod();
}

class Worker
{   
    public static ArrayList<String> names = new ArrayList<String>();
    static Timer t = new Timer();

    public void addToList(String newAdd, CallableInterface callback)
    {   
        names.add("BMW");
        names.add("DODGE");

        t.schedule(new TimerTask() {
            @Override
            public void run() {     
                names.add(newAdd);
            }
        }, 5000);

       callback.callBackMethod();
    }

    public void printList(){
        System.out.println(Worker.names);
    }
}


class Boss implements CallableInterface
{   
    Worker w1 = new Worker();

    public Boss(String carName)
    {   
        w1.addToList(carName, this);
    }
    public void callBackMethod()
    {
        w1.printList();
    }
}


public class IntroCallbacks
{ 
    public static void main(String[] args)
    {
        Boss b = new Boss("Mercedes");   
    }
}

---

或者使用一些同步机制，如

此代码将修复您的问题：）

import java.util.ArrayList；
导入java.util.Timer；
导入java.util.TimerTask；
接口可调用接口
{
void callBackMethod（）；
}
班主任
{   
public static ArrayList names=new ArrayList（）；
静态定时器t=新定时器（）；
public void addToList（字符串newAdd，CallableInterface回调）
{   
名称。添加（“宝马”）；
名称。添加（“道奇”）；
t、 附表（新TimerTask（）{
@凌驾
public void run（）{
name.add（newAdd）；
callback.callBackMethod（）；
}
}, 5000);
}
公共作废打印列表（）{
System.out.println（Worker.names）；
}
}
类Boss实现CallableInterface
{   
工人w1=新工人（）；
公共老板（我）
{   
w1.地址列表（卡纳姆，本）；
}
public void callBackMethod（）
{
w1.打印列表（）；
}
}
公共班机{
公共静态void main（字符串[]args）{
Boss b=新Boss（“梅赛德斯”）；
}
}

在添加名称后，我将使用

CompletableFuture

链接打印。您可以使用延迟的

执行器

而不是

计时器

来引入5秒延迟

    import java.util.ArrayList;
    import java.util.Timer;
    import java.util.TimerTask;

    interface CallableInterface
    {
        void callBackMethod();
    }

    class Worker
    {   
        public static ArrayList<String> names = new ArrayList<String>();
        static Timer t = new Timer();

        public void addToList(String newAdd, CallableInterface callback)
        {   
            names.add("BMW");
            names.add("DODGE");

            t.schedule(new TimerTask() {
                @Override
                public void run() {     
                    names.add(newAdd);
                    callback.callBackMethod();
                }
            }, 5000);


        }

        public void printList(){
            System.out.println(Worker.names);
        }
    }


    class Boss implements CallableInterface
    {   
        Worker w1 = new Worker();

        public Boss(String carName)
        {   
            w1.addToList(carName, this);
        }
        public void callBackMethod()
        {
            w1.printList();
        }
    }

    public class Main {

        public static void main(String[] args) {
            Boss b = new Boss("Mercedes");   

        }

    }

导入静态java.util.concurrent.TimeUnit.SECONDS；
导入java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.CompletableFuture；
导入java.util.concurrent.Executor；
班主任{
私有列表名称=新的ArrayList（）；
公共CompletableFuture addToList（字符串名称，可运行回调）{
名称。添加（“宝马”）；
名称。添加（“道奇”）；
5秒内执行器=可完成的未来。延迟执行器（5秒）；
返回CompletableFuture.runAsync（（）->names.add（name），5秒后返回）
.thenRun（回调：：run）；
}
公共作废打印列表（）{
System.out.println（名称）；
}
}
类Boss实现了Runnable{
私人工作者=新工作者（）；
私人企业的未来；
公共老板（我）{
future=worker.addToList（carName，this）；
}
公开募捐{
worker.printList（）；
}
public CompletableFuture getFuture（）{
回归未来；
}
}
公共类回调{
公共静态void main（字符串[]args）{
Boss Boss=新Boss（“梅赛德斯”）；
boss.getFuture（）.join（）；
}
}

---

必须等到将来的

isDone（）

或最后的

join（）

，否则程序将结束，后台守护进程线程将在任何有趣的事情（包括输出）发生之前终止。

您正在调用回调方法，然后，5秒后，添加MERCEDES。您可能希望在

run（）

方法中调用回调。注意：您可以使用

Runnable

而不是定义自己的

CallbackInterface

。为什么要这样做？谢谢Michael:）这样做很有效，但将回调调用放在那里让我觉得有点脏。这感觉像是一个跨领域的问题，我认为一个更干净的方法可能是通过链接承诺，或者在Java中，

CompletableFuture

s.@DavidConrad同意，但要迎合你的观众。看看他的代码，认真地问问自己，他是否能听懂你刚才说的话。我确实建议在底部使用同步辅助工具，以防他想查看。这就是为什么我刚刚发布了一个单独的答案来演示它。不要说你的答案不好。@Michael你是对的。我被DavidConrad的回答弄糊涂了，因为我是Java的初学者。但是，通过简单的谷歌搜索，我熟悉了CountDownLatch和CompletableFuture，目前我正在使用它们专业化我的代码；）美好的值得注意的是，

CompletableFuture.delayedExecutor

只出现在Java 9及以上版本中，因为很多人还没有做出改变。@Michael，这是个好主意。我只是查了一下文件，在那里找到了。没有注意到这是从Java9开始的。谢谢@Davi

    import java.util.ArrayList;
    import java.util.Timer;
    import java.util.TimerTask;

    interface CallableInterface
    {
        void callBackMethod();
    }

    class Worker
    {   
        public static ArrayList<String> names = new ArrayList<String>();
        static Timer t = new Timer();

        public void addToList(String newAdd, CallableInterface callback)
        {   
            names.add("BMW");
            names.add("DODGE");

            t.schedule(new TimerTask() {
                @Override
                public void run() {     
                    names.add(newAdd);
                    callback.callBackMethod();
                }
            }, 5000);


        }

        public void printList(){
            System.out.println(Worker.names);
        }
    }


    class Boss implements CallableInterface
    {   
        Worker w1 = new Worker();

        public Boss(String carName)
        {   
            w1.addToList(carName, this);
        }
        public void callBackMethod()
        {
            w1.printList();
        }
    }

    public class Main {

        public static void main(String[] args) {
            Boss b = new Boss("Mercedes");   

        }

    }

import static java.util.concurrent.TimeUnit.SECONDS;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;

class Worker {
    private List<String> names = new ArrayList<String>();

    public CompletableFuture<Void> addToList(String name, Runnable callback) {
        names.add("BMW");
        names.add("DODGE");

        Executor in5seconds = CompletableFuture.delayedExecutor(5, SECONDS);

        return CompletableFuture.runAsync(() -> names.add(name), in5seconds)
            .thenRun(callback::run);
    }

    public void printList() {
        System.out.println(names);
    }
}

class Boss implements Runnable {
    private Worker worker = new Worker();
    private CompletableFuture<Void> future;

    public Boss(String carName) {
        future = worker.addToList(carName, this);
    }

    public void run() {
        worker.printList();
    }

    public CompletableFuture<Void> getFuture() {
        return future;
    }
}

public class IntroCallbacks {
    public static void main(String[] args) {
        Boss boss = new Boss("Mercedes");
        boss.getFuture().join();
    }
}