Java 在不执行新操作的情况下调用函数

我用Java编写了一个排序函数和类：

public class MiscellaneousUtilities {

    /**
     * Changes a list of "First Last" to "Last, First" and "First Middle Last" to "Last, First Middle", etc.
     */
    public static Function<String, String> ToLastFirstFunction = new Function<String, String>() {
        @Override
        public String apply(String nm) {
            String[] nmarr = nm.split(" ");
            int last = nmarr.length - 1;
            String res = nmarr[last];
            if (last > 0) {
                res += ",";
            }

            for (int i = 0; i < last; i++) {
                res += " " + nmarr[i];
            }

            return res;
        };
    };
}

公共类杂项用途{
/**
*将“First Last”列表更改为“Last，First”，将“First Middle Last”列表更改为“Last，First Middle”，等等。
*/
公共静态函数ToLastFirstFunction=新函数（）{
@凌驾
公共字符串应用（字符串nm）{
字符串[]nmarr=nm.split（“”）；
int last=nmarr.length-1；
字符串res=nmarr[last]；
如果（上次>0）{
res+=“，”；
}
for（int i=0；i

---

当我想使用它时，我不能只说

MiscellaneousFunctions.ToFirstLastFunction（）

我必须做一个新的

MiscellaneousFunctions（）.ToFirstLastFunction

我尝试将static放在类声明之前，但它只允许public、final和abstract。如果我想使用
Math.min（）
我不需要做一个新的
Math（）.min（）
，请看数学类。Math也被定义为一个前面没有
static
的类，
min（）
和
ToFirstLastFunction
一样，所以我不理解它们之间的区别。
这是因为你必须用
apply
这样调用该函数：

MiscellaneousFunctions.ToFirstLastFunction.apply("yourstring");

您可以添加另一个
静态
函数作为速记：

public static String toFirstLast(String str) {
    return ToLastFirstFunction.apply(str);
}

Math.min
与您的解决方案的主要区别在于
Math.min
是一个常规的
静态方法，而您有一个
函数
对象，可以使用
apply
调用这些对象，您的
函数
是
函数
对象，而不是方法。您的对象有一个方法
apply
，您必须将该方法用于您想要实现的目标，如下所示：

MiscellaneousFunctions.ToFirstLastFunction.apply("yourstring");

MiscellaneousFunctions.ToFirstLastFunction.apply（某物）
Math.min（）
是一个方法而不是函数，在
Math.class
中声明如下：

public int min(int a, int b) {
    ...
}

。。。您可以像在
intx=Math.min（3,2）
中那样直接调用这样的方法

您已经创建了一个名为
ToLastFirstFunction
的
public static
类变量——这不是像方法那样可以调用的。但是您可以使用
java.util.function.function
接口中的方法来处理它——最简单的方法是
apply（）
：

（我更改了标识符的资本化--了解Java资本化约定）


您可以使用
新的MiscellaneousFunctions（）.toFirstLastFunction（“John Doe”）
调用您的
公共静态函数，但并非如此

您可以执行
newMiscellanusFunctions（）.toFirstLastFunction.apply（“John Doe”）
——但编译器应该警告您，不要通过实例访问
静态
变量<代码>杂项函数.toFirstLastFunction.apply（）
是正确的方法


因此，对您的问题的简短回答是：如果您希望以这种方式调用它，请将其作为方法编写


但如果是这样，为什么要将操作定义为函数而不是方法

函数的好处是，与方法（*）不同，它们是对象——因此您可以传递它们，将它们放入集合，将它们分配给变量。它们有一些方法，比如
compose（）
和
And（）
，这些方法返回一个新函数，该函数将这个函数与另一个函数结合起来

因此，您可以执行以下操作：

Map<String,Function<String,String> nameTranslationStrategies = new HashMap<>();
nameTranslationStrategies.put(
   "no change", x -> x);
nameTranslationStrategies.put(
   "to first-last", 
   MiscellaneousFunctions.toFirstLastFunction);
nameTranslationStrategies.put(
   "capitalised first-last",
   MiscellaneousFunctions.toFirstLastFunction
        .andThen( s -> s.toUpperCase());

...

String nameTranslationOption = config.getProperty("nameTranslationOption");
String name = nameTranslationStrategies
     .get(nameTranslationOption)
     .apply(inputString);


还要注意，您使用了冗长的语法来定义函数：

 public static Function<String, String> slimify = new Function<String, String>() {
    @Override
    public String apply(String s) {
         return "slim says " + s;
    }
 }

公共静态函数slimify=新函数（）{
@凌驾
公共字符串应用（字符串s）{
返回“slim says”+s；
}
}

。。。可以写为：

public static Function<String,String> slimify = s -> {
    return "slim says " + s;
}

公共静态函数slimify=s->{
返回“slim says”+s；
}

。。。或者甚至（因为这是一条单行线）

公共静态函数slimify=s->“slim说”+s；

了解冗长的方式很好，因为它显示了函数在幕后是如何工作的。但在现实世界的代码中，简短的形式是最好的选择，因为它更具表现力：代码的意图不会被混乱所掩盖。这是一种表达函数的快速而简单的方法，人们经常在线使用它们，而不是将它们赋给变量——正如我在上面的映射示例中所做的那样


（*）我说过方法不是对象。严格来说，这并不是真的——部分原因是您可以使用
：
获取一个对象，但也因为您可以使用Java的反射API作为对象访问类和方法。但是，除非您确实知道需要使用反射，否则您不想使用反射。
MiscellaneousFunctions.ToFirstLastFunction（）
不起作用，但
MiscellaneousFunctions.ToFirstLastFunction.apply（“foo”）
should。您实际创建的是
Function
类型的静态变量，而不是可以调用的方法，如
Math.min（）
如果将
ToLastFirstFunction
更改为实际函数，则可以调用它，如
Misc.ToLastFirst（）
public static Function<String,String> slimify = s -> {
    return "slim says " + s;
}

public static Function<String,String> slimify = s -> "slim says " + s;