Java 自定义花括号方法

在java中，一些标准库方法（可能不是真正的方法？）具有以下格式：

keyword(condition or statements) {
//write your code here
}

这包括if语句、for循环、while循环、do while循环等

for(initialValue = n; conditionForLoopToContinue; incrementOrDecrement) {
//write your code
}

您还可以启动匿名线程，如下所示：

new Thread() {
//write your code here
}.start();

我想知道的是，我们是否可以创建自己的方法（或实际上调用它们的任何方法）来使用这种花括号格式

例如，我会写一个'until'方法，如下所示：

int a = 0;
until(a == 10) {
a++;
}

其中，until（a==10）等于while（a！=10）

当然，上面的例子不允许我们做任何新的事情（我们可以使用while循环），但是这个问题的目的是找出我们是否可以编写“自定义花括号方法”

另外，如果你们知道任何语言有这个功能或类似的，请让我知道

---

提前谢谢你的帮助

您无法实现自己的关键字。当然，您可以创建自己类的匿名子类，也就是说，您可以

new YourOwnClass() {
    // write your code here
}.launch();

如果你愿意的话

使用Java8，您可以进一步了解所要求的花括号语法。下面是我尝试使用lambdas来模拟您的

util

方法：

public class Scratch {

    static int a;

    public static void until(Supplier<Boolean> condition, Runnable code) {
        while (!condition.get())
            code.run();
    }

    public static void main(String[] args) {
        a = 0;
        until(() -> a == 10, () -> {
            System.out.println(a);
            a++;
        });
    }
}

---

请注意，在这个稍微做作的示例中，存在一些限制<代码>例如，由于闭包，一个需要是一个字段或一个常量变量。

事实上，您正在扩展该语言，即发明一个新的“保留字”，并说这个保留字后面必须跟一个布尔表达式和一个语句（块）

仅是您需要一个新的保留字这一事实就可能导致许多问题，例如，人们今天可能已经在变量的上下文中使用了单词

，直到
。你的新功能将破坏这一代码

您还需要告诉运行时环境新语句的效果

我不知道哪种语言可以简单地做到这一点。就像@aioobe所说的，lambdas可能很接近。
不如aioobe的优雅：

abstract class until<T> {
    // An attempt at an `until` construct.

    // The value.
    final T value;
    // The test.
    final Function<T, Boolean> test;

    public until(T v, Function<T, Boolean> test) {
        this.value = v;
        this.test = test;
    }

    public void loop() {
        while (!test.apply(value)) {
            step();
        }
    }

    abstract void step();
}

public void test() {
    AtomicInteger a = new AtomicInteger();
    new until<AtomicInteger>(a, x -> x.get() == 10) {

        @Override
        void step() {
            a.getAndIncrement();
        }

    }.loop();
    System.out.println("a=" + a);
}

在中有一整套条件
WHILE
，
UNTIL
，
IF
和
除非
等等。
当然你可以拥有这样的方法和格式，但你的
UNTIL
示例不是自己的方法，而是尝试创建一个新的关键字。如果，while等是在语言中构建的，而不是实际的函数。您的Thread（）示例是一个新的（匿名）对象，与我提出的非常相似，但更加优雅。我对
a
使用了泛型，但这可能不适用于您的。这有一个限制，即您的条件取决于单个变量。（顺便说一句，您可以改用谓词）
abstract class until<T> {
    // An attempt at an `until` construct.

    // The value.
    final T value;
    // The test.
    final Function<T, Boolean> test;

    public until(T v, Function<T, Boolean> test) {
        this.value = v;
        this.test = test;
    }

    public void loop() {
        while (!test.apply(value)) {
            step();
        }
    }

    abstract void step();
}

public void test() {
    AtomicInteger a = new AtomicInteger();
    new until<AtomicInteger>(a, x -> x.get() == 10) {

        @Override
        void step() {
            a.getAndIncrement();
        }

    }.loop();
    System.out.println("a=" + a);
}

#define until(e) while(!(e))