将函数作为参数传递给java

6 回答

• 89

  使用带有抽象回调方法的回调接口或抽象类 .

  回调接口示例：

  public class SampleActivity extends Activity {
  
      //define callback interface
      interface MyCallbackInterface {
  
          void onDownloadFinished(String result);
      }
  
      //your method slightly modified to take callback into account 
      public void downloadUrl(String stringUrl, MyCallbackInterface callback) {
          new DownloadWebpageTask(callback).execute(stringUrl);
      }
  
      @Override
      protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
  
          //example to modified downloadUrl method
          downloadUrl("http://google.com", new MyCallbackInterface() {
  
              @Override
              public void onDownloadFinished(String result) {
                  // Do something when download finished
              }
          });
      }
  
      //your async task class
      private class DownloadWebpageTask extends AsyncTask<String, Void, String> {
  
          final MyCallbackInterface callback;
  
          DownloadWebpageTask(MyCallbackInterface callback) {
              this.callback = callback;
          }
  
          @Override
          protected void onPostExecute(String result) {
              callback.onDownloadFinished(result);
          }
  
          //except for this leave your code for this class untouched...
      }
  }
  

  第二种选择更简洁 . 你甚至不需要为"onDownloaded event"定义一个抽象方法，因为 onPostExecute 确实需要它 . 只需在 downloadUrl 方法中使用匿名内联类扩展 DownloadWebpageTask .

  //your method slightly modified to take callback into account 
      public void downloadUrl(String stringUrl, final MyCallbackInterface callback) {
          new DownloadWebpageTask() {
  
              @Override
              protected void onPostExecute(String result) {
                  super.onPostExecute(result);
                  callback.onDownloadFinished(result);
              }
          }.execute(stringUrl);
      }
  
      //...
  

  回复于 2024-04-23T16:35:56+08:00
• 4

  是的，界面是恕我直言的最佳方式 . 例如，GWT使用带有如下界面的命令模式：

  public interface Command{
      void execute();
  }
  

  通过这种方式，您可以将函数从方法传递到另一个方法

  public void foo(Command cmd){
    ...
    cmd.execute();
  }
  
  public void bar(){
    foo(new Command(){
       void execute(){
          //do something
       }
    });
  }
  

  回复于 2024-04-23T16:35:56+08:00
• 10

  NO interface, NO lib, NO Java 8 needed!

  刚刚从 java.util.concurrent 使用 Callable<V>

  public static void superMethod(String simpleParam, Callable<Void> methodParam) {
  
      //your logic code [...]
  
      //call methodParam
      try {
          methodParam.call();
  
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
  

  How to use it:

  superMethod("Hello world", new Callable<Void>() {
                  public Void call() {
                      myParamMethod();
                      return null;
                  }
              }
      );
  

  myParamMethod() 是我们传递的方法作为参数（在本例中为 methodParam ） .

  回复于 2024-04-23T16:35:56+08:00
• 20

  开箱即用的解决方案是Java中不可能实现这一点 . Java不接受Higher-order functions . 它可以通过一些"tricks"来实现 . 通常，界面是您看到的那个 . 请查看here了解更多信息 . 您也可以使用反射来实现它，但这很容易出错 .

  回复于 2024-04-23T16:35:56+08:00
• 12

  使用接口可能是Java编码体系结构中的最佳方式 .

  但是，传递一个Runnable对象也可以正常工作，我认为它会更加实用和灵活 .

  SomeProcess sp;
  
   public void initSomeProcess(Runnable callbackProcessOnFailed) {
       final Runnable runOnFailed = callbackProcessOnFailed; 
       sp = new SomeProcess();
       sp.settingSomeVars = someVars;
       sp.setProcessListener = new SomeProcessListener() {
            public void OnDone() {
               Log.d(TAG,"done");
            }
            public void OnFailed(){
               Log.d(TAG,"failed");
               //call callback if it is set
               if (runOnFailed!=null) {
                 Handler h = new Handler();
                 h.post(runOnFailed);
               }
            }               
       };
  }
  
  /****/
  
  initSomeProcess(new Runnable() {
     @Override
     public void run() {
         /* callback routines here */
     }
  });
  

  回复于 2024-04-23T16:35:56+08:00
• 0

  反射从来都不是一个好主意，因为它更难以阅读和调试，但如果你100％确定你正在做什么，你可以简单地调用类似set_method（R.id.button_profile_edit，“toggle_edit”）的方法来附加一个方法一个看法 . 这在片段中很有用，但有些人会认为它是反模式所以要警告 .

  public void set_method(int id, final String a_method)
  {
      set_listener(id, new View.OnClickListener() {
          public void onClick(View v) {
              try {
                  Method method = fragment.getClass().getMethod(a_method, null);
                  method.invoke(fragment, null);
              } catch (Exception e) {
                  Debug.log_exception(e, "METHOD");
              }
          }
      });
  }
  public void set_listener(int id, View.OnClickListener listener)
  {
      if (root == null) {
          Debug.log("WARNING fragment", "root is null - listener not set");
          return;
      }
      View view = root.findViewById(id);
      view.setOnClickListener(listener);
  }
  

  回复于 2024-04-23T16:35:56+08:00