如何在类之间执行JAVAcallback？
我来自JavaScript，其中callback非常简单。 我试图将它们实现到JAVA，没有成功。
我有一个父类：
import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Server { ExecutorService workers = Executors.newFixedThreadPool(10); private ServerConnections serverConnectionHandler; public Server(int _address) { System.out.println("Starting Server..."); serverConnectionHandler = new ServerConnections(_address); serverConnectionHandler.newConnection = function(Socket _socket) { System.out.println("A function of my child class was called."); }; workers.execute(serverConnectionHandler); System.out.println("Do something else..."); } } 然后，我有一个从父级调用的子类：
import java.io.IOException; import java.net.ServerSocket; import java.net.Socket; import java.util.logging.Level; import java.util.logging.Logger; public class ServerConnections implements Runnable { private int serverPort; private ServerSocket mainSocket; public ServerConnections(int _serverPort) { serverPort = _serverPort; } @Override public void run() { System.out.println("Starting Server Thread..."); try { mainSocket = new ServerSocket(serverPort); while (true) { newConnection(mainSocket.accept()); } } catch (IOException ex) { Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex); } } public void newConnection(Socket _socket) { } }
什么是正确的执行方式
serverConnectionHandler.newConnection = function(Socket _socket) { System.out.println("A function of my child class was called."); };
部分，在父类，这显然是不正确的？
定义一个接口，并在接收callback的类中实现它。
请注意您的情况下的multithreading。
interface CallBack { void methodToCallBack(); } class CallBackImpl implements CallBack { public void methodToCallBack() { System.out.println("I've been called back"); } } class Caller { public void register(CallBack callback) { callback.methodToCallBack(); } public static void main(String[] args) { Caller caller = new Caller(); CallBack callBack = new CallBackImpl(); caller.register(callBack); } }
使用观察者模式。 它是这样工作的：
interface MyListener{ void somethingHappened(); } public class MyForm implements MyListener{ MyClass myClass; public MyForm(){ this.myClass = new MyClass(); myClass.addListener(this); } public void somethingHappened(){ System.out.println("Called me!"); } } public class MyClass{ private List<MyListener> listeners = new ArrayList<MyListener>(); public void addListener(MyListener listener) { listeners.add(listener); } void notifySomethingHappened(){ for(MyListener listener : listeners){ listener.somethingHappened(); } } }
您创build了一个接口，该接口在发生某些事件时会调用一个或多个方法。 然后，任何事件发生时需要通知的类实现这个接口。
这允许更多的灵活性，因为生产者只知道监听器接口， 而不是监听器接口的特定实现。
在我的例子中：
MyClass是这里的生产者，因为它通知了一个监听器列表。
MyListener是接口。
当somethingHappened ， MyForm感兴趣，因此正在实现MyListener并使用MyClass注册自己。 现在， MyClass可以通知MyForm有关事件，而不直接引用MyForm 。 这是观察者模式的优势，它降低了依赖性并提高了可重用性。
国际海事组织，你应该看看观察者模式 ，这是大多数听众的工作原理
我不知道这是你在找什么，但是你可以通过给孩子类传递一个callback来实现。
首先定义一个通用callback：
public interface ITypedCallback<T> { void execute(T type); }
在ServerConnections实例化上创build一个新的ITypedCallback实例：
public Server(int _address) { serverConnectionHandler = new ServerConnections(new ITypedCallback<Socket>() { @Override public void execute(Socket socket) { // do something with your socket here } }); }
调用callback对象上的执行方法。
public class ServerConnections implements Runnable { private ITypedCallback<Socket> callback; public ServerConnections(ITypedCallback<Socket> _callback) { callback = _callback; } @Override public void run() { try { mainSocket = new ServerSocket(serverPort); while (true) { callback.execute(mainSocket.accept()); } } catch (IOException ex) { Logger.getLogger(Server.class.getName()).log(Level.SEVERE, null, ex); } } }
顺便说一句：我没有检查是否100％正确，直接编码在这里。
在这个特定的情况下，以下应该工作：
serverConnectionHandler = new ServerConnections(_address) { public void newConnection(Socket _socket) { System.out.println("A function of my child class was called."); } };
这是一个匿名的子类。
