java - 有没有办法在 Java 中传递方法引用？

Question

首先，这不是 this question 的副本，即使它们具有相同的标题。这个问题指的是传递与 C 函数基本相同的方法:它们不需要属于特定对象。在这种情况下，您可以传递一个 Runnable 或 Callable 对象。

相反，我问的是:是否可以传递对类中特定方法的引用，并为特定对象调用该方法？

例如，我正在查看 Swing 中的 FlowLayout 代码，并注意到 preferredLayoutSize 和 minimumLayoutSize 实现完全相同，除了一行:

public Dimension preferredLayoutSize(Container target) {
  synchronized (target.getTreeLock()) {
    Dimension dim = new Dimension(0, 0);
    int nmembers = target.getComponentCount();
    boolean firstVisibleComponent = true;
    boolean useBaseline = getAlignOnBaseline();
    int maxAscent = 0;
    int maxDescent = 0;

    for (int i = 0 ; i < nmembers ; i++) {
        Component m = target.getComponent(i);
        if (m.isVisible()) {
            Dimension d = m.getPreferredSize();
            dim.height = Math.max(dim.height, d.height);
            if (firstVisibleComponent) {
                firstVisibleComponent = false;
            } else {
                dim.width += hgap;
            }
            dim.width += d.width;
            if (useBaseline) {
                int baseline = m.getBaseline(d.width, d.height);
                if (baseline >= 0) {
                    maxAscent = Math.max(maxAscent, baseline);
                    maxDescent = Math.max(maxDescent, d.height - baseline);
                }
            }
        }
    }
    if (useBaseline) {
        dim.height = Math.max(maxAscent + maxDescent, dim.height);
    }
    Insets insets = target.getInsets();
    dim.width += insets.left + insets.right + hgap*2;
    dim.height += insets.top + insets.bottom + vgap*2;
    return dim;
  }
}

public Dimension minimumLayoutSize(Container target) {
  synchronized (target.getTreeLock()) {
    boolean useBaseline = getAlignOnBaseline();
    Dimension dim = new Dimension(0, 0);
    int nmembers = target.getComponentCount();
    int maxAscent = 0;
    int maxDescent = 0;
    boolean firstVisibleComponent = true;

    for (int i = 0 ; i < nmembers ; i++) {
        Component m = target.getComponent(i);
        if (m.visible) {
            Dimension d = m.getMinimumSize();
            dim.height = Math.max(dim.height, d.height);
            if (firstVisibleComponent) {
                firstVisibleComponent = false;
            } else {
                dim.width += hgap;
            }
            dim.width += d.width;
            if (useBaseline) {
                int baseline = m.getBaseline(d.width, d.height);
                if (baseline >= 0) {
                    maxAscent = Math.max(maxAscent, baseline);
                    maxDescent = Math.max(maxDescent,
                                          dim.height - baseline);
                }
            }
        }
    }

    if (useBaseline) {
        dim.height = Math.max(maxAscent + maxDescent, dim.height);
    }

    Insets insets = target.getInsets();
    dim.width += insets.left + insets.right + hgap*2;
    dim.height += insets.top + insets.bottom + vgap*2;
    return dim;
  }
}

preferredLayoutSize 方法调用 m(第 i 组件)的 preferredLayoutSize 方法，而 minimumLayoutSize调用m的minimumLayoutSize方法。据我所知，这两种方法在其他方面是相同的。

与任何programmer一样会告诉你，代码重复是一件坏事。然而，在这种情况下，如何摆脱重复的代码并不明显。很明显，应该有一个私有(private)方法，其中包含两个公共(public)方法调用的代码，传递对 的 preferredLayoutSize 和 minimumLayoutSize 方法的引用组件类。在 C 中，我可以使用函数指针来做到这一点，因此在 Java 中应该有某种方式来做到这一点是有道理的。传入 Runnable 或 Callable 几乎可以工作，但都不会返回值。 编辑:这是错误的。 Callable 中的覆盖方法确实 返回一个值，并且它所作用的对象可以作为参数传入。

既然我已经输入了所有内容，我想到了一个解决方案:您可以使用名为 Dimension layoutSize(Component comp) 的方法编写一个 interface 并编写两个实现，其中一个返回 comp.preferredLayoutSize()，另一个返回 comp.minimumLayoutSize()。然后，您可以编写一个私有(private)方法，将该接口(interface)的实例作为参数，并使用它在代码中的正确位置运行单独的方法。您甚至可以使用匿名内部类，这样您就不必为每种类型的布局大小编写一个新类。不过，对于一个相当简单的问题来说，这似乎仍然很麻烦。有没有更简单的方法？

Answer 1

您可以将其中一种方法包装在类LayoutSizing(可能是本地类)中，使用抽象方法在m 上进行计算，使用m 作为参数，然后在两种方法中实例化 new LayoutSizing() { @Override ... } 并实现该方法。

在 Java 8 中，这有望变得更漂亮。