如何用Java编写匿名函数？

Question

有可能吗？

Answer 1

如果您指的是匿名函数，并且使用的是 Java 8 之前的 Java 版本，那么一句话，不。 请阅读 lambda 表达式）

（如果您使用 Java 8+ ， ，您可以使用如下函数实现接口：

Comparator<String> c = new Comparator<String>() {
    int compare(String s, String s2) { ... }
};

并且您可以将其与内部类一起使用以获得几乎匿名的函数:)

Answer 2

这是匿名内部类的示例。

System.out.println(new Object() {
    @Override public String toString() {
        return "Hello world!";
    }
}); // prints "Hello world!"

这并不是很有用，但它展示了如何创建一个匿名内部类的实例，该内部类扩展 Object 和 @Override 其 toString()< /代码> 方法。

另请参见

• JLS 15.9.5 匿名类声明

---

当您需要实现一个可能不具有高度可重用性的接口（因此不值得重构为自己的命名类）时，匿名内部类非常方便。一个有指导意义的示例是使用自定义 java.util .Comparator 用于排序。

以下示例展示了如何根据 String.length() 对 String[] 进行排序。

import java.util.*;
//...

String[] arr = { "xxx", "cd", "ab", "z" };
Arrays.sort(arr, new Comparator<String>() {
    @Override public int compare(String s1, String s2) {
        return s1.length() - s2.length();
    }           
});
System.out.println(Arrays.toString(arr));
// prints "[z, cd, ab, xxx]"

注意这里使用的减法比较技巧。应该说，这种技术一般来说是有缺陷的：它仅适用于可以保证它不会溢出的情况（例如 String 长度的情况）。

另请参阅

• Java 整数：什么是更快的比较或减法？
  • 减法比较通常被破坏
• 使用自定义比较器在 Java 中创建排序哈希
• Java 中如何使用匿名（内部）类？

Answer 3

随着 Java 8 中引入 lambda 表达式，您现在可以拥有匿名方法。

假设我有一个类 Alpha，并且我想根据特定条件过滤 Alpha。为此，您可以使用 Predicate< ;阿尔法>。这是一个函数式接口，有一个方法 test，该方法接受 Alpha 并返回 boolean。

假设过滤器方法具有以下签名：

List<Alpha> filter(Predicate<Alpha> filterPredicate)

使用旧的匿名类解决方案，您将需要类似的内容：

filter(new Predicate<Alpha>() {
   boolean test(Alpha alpha) {
      return alpha.centauri > 1;
   }
});

使用 Java 8 lambda，您可以执行以下操作：

filter(alpha -> alpha.centauri > 1);

有关更多详细信息，请参阅 Lambda 表达式教程

Answer 4

匿名内部类实现或扩展现有类型的接口已在其他答案中完成，但值得注意的是可以实现多种方法（例如，通常使用 JavaBean 样式事件）。

一个公认的特点是，虽然匿名内部类没有名称，但它们确实有类型。可以将新方法添加到接口中。这些方法只能在有限的情况下调用。主要直接在 new 表达式本身和类内（包括实例初始化程序）。它可能会让初学者感到困惑，但它对于递归来说可能是“有趣的”。

private static String pretty(Node node) {
    return "Node: " + new Object() {
        String print(Node cur) {
            return cur.isTerminal() ?
                cur.name() :
                ("("+print(cur.left())+":"+print(cur.right())+")");
        }
    }.print(node);
}

（我最初在 print 方法中使用 node 而不是 cur 来编写此代码。对“隐式捕获”说“不”final< /code>" 当地人？)

Answer 5

是的，如果您使用的是 Java 8 或更高版本。 Java 8 使得定义匿名函数成为可能，这在以前的版本中是不可能的。

让我们以 java 文档 为例来了解我们如何声明匿名函数、类

以下示例 HelloWorldAnonymousClasses 使用匿名
类中局部变量的初始化语句
frenchGreeting 和 spanishGreeting，但使用本地类
变量 englishGreeting 的初始化：

public class HelloWorldAnonymousClasses {
  
    interface HelloWorld {
        public void greet();
        public void greetSomeone(String someone);
    }
  
    public void sayHello() {
        
        class EnglishGreeting implements HelloWorld {
            String name = "world";
            public void greet() {
                greetSomeone("world");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hello " + name);
            }
        }
      
        HelloWorld englishGreeting = new EnglishGreeting();
        
        HelloWorld frenchGreeting = new HelloWorld() {
            String name = "tout le monde";
            public void greet() {
                greetSomeone("tout le monde");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Salut " + name);
            }
        };
        
        HelloWorld spanishGreeting = new HelloWorld() {
            String name = "mundo";
            public void greet() {
                greetSomeone("mundo");
            }
            public void greetSomeone(String someone) {
                name = someone;
                System.out.println("Hola, " + name);
            }
        };
        englishGreeting.greet();
        frenchGreeting.greetSomeone("Fred");
        spanishGreeting.greet();
    }

    public static void main(String... args) {
        HelloWorldAnonymousClasses myApp =
            new HelloWorldAnonymousClasses();
        myApp.sayHello();
    }            
}

匿名类的语法

考虑 frenchGreeting 对象的实例化：

    HelloWorld frenchGreeting = new HelloWorld() {
        String name = "tout le monde";
        public void greet() {
            greetSomeone("tout le monde");
        }
        public void greetSomeone(String someone) {
            name = someone;
            System.out.println("Salut " + name);
        }
    };

匿名类表达式由以下部分组成：

• new 运算符

• 要实现的接口或要扩展的类的名称。在这个
  例如，匿名类正在实现接口
  你好世界。

• 包含构造函数参数的括号，就像
  普通类实例创建表达式。注意：当你实施
  一个接口，没有构造函数，所以你使用一个空的对
  括号，如本例所示。

• 主体，即类声明主体。更具体地说，在
  允许主体、方法声明，但不允许声明。

Answer 6

您还可以根据需要的参数数量使用 Consumer 和 BiConsumer 类型。 Consumer 接受一个参数，BiConsumer 接受两个参数。

public void myMethod() {
  // you can declare it here
  Consumer<String> myAnonymousMethod = s -> {
    System.out.println(s);
  };

  // you can call it here
  muAnonymousMethod.apply("Hello World");
}