Lambda vs Anon vs静态嵌套类

Question

这个类有三个方法执行相同的操作，它们等待页面加载三秒钟，如果页面加载，则返回true。
我的问题是，我如何决定哪段代码是最好的？
我知道Lambda比Anon类更好，但为什么静态嵌套类(pageLoaded3)不好呢？根据这篇文章，它也应该是合适的。

public final class ExpectedConditions {

    private ExpectedConditions() {
    }

    public static ExpectedCondition<Boolean> pageLoaded1() {
        return (driver) -> {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return !((JavascriptExecutor) driver).executeScript("return performance.timing.loadEventEnd", new Object[0])
                    .equals("0");
        };
    }

    public static ExpectedCondition<Boolean> pageLoaded2() {
        return new ExpectedCondition<Boolean>() {
            @Override
            public Boolean apply(WebDriver driver) {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return !((JavascriptExecutor) driver)
                        .executeScript("return performance.timing.loadEventEnd", new Object[0]).equals("0");
            }
        };
    }

    public static ExpectedCondition<Boolean> pageLoaded3() {
        return new PageLoaded();
    }

    private static class PageLoaded implements ExpectedCondition<Boolean> {
        @Override
        public Boolean apply(WebDriver driver) {
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return !((JavascriptExecutor) driver).executeScript("return performance.timing.loadEventEnd", new Object[0])
                    .equals("0");
        }
    }

}

这是三个方法返回类型的接口：

public interface ExpectedCondition<T> extends Function<WebDriver, T> {}

Answer 1

正如评论中已经提到的：功能相当。所以从技术上来说，差别是边际的。所有方法都编译成类似的字节码。所以关于哪一个是“最好”的问题只能从代码本身来回答。在这方面，可以采用不同的标准。

首先，正如Peter Lawrey在评论中所建议的：您可以将thread.sleep调用拉出到一个helper方法中：

private static void pause(long ms)
{
    try
    {
        Thread.sleep(ms);
    }
    catch (InterruptedException e)
    {
        Thread.currentThread().interrupt();
    }
}

此外,您可以将在那里实现的核心功能提取到一个helper方法中：

private static Boolean execute(WebDriver driver)
{
    pause(3000);
    return !((JavascriptExecutor) driver)
        .executeScript("return performance.timing.loadEventEnd", new Object[0])
        .equals("0");
}

public static ExpectedCondition<Boolean> pageLoaded4()
{
    return ExpectedConditions::execute;
}

1. 带有lambda
2. 具有匿名类
3. 具有静态innner类
4. 具有方法引用

从实际意义上讲,人们可以争论利弊：

>

方法3，带有静态innner类：这不是必需的。如果静态内部类只是一个方法调用的包装器，那么它并不起到真正的作用。它引入了一个新名称（在您的例子中为PageLoaded)和源代码中的一个新间接--这意味着程序员必须查找PageLoaded类来查看它的功能。在其他情况下，情况可能不同。例如。如果PageLoaded类有其他方法或字段，但这里不是这样。

方法1，使用lambda：这是在Java8中实现这样一个功能接口的标准方法。就我个人而言，我更喜欢拥有短小的lambda身材。就像你问题中的那个

return (driver) -> {
    // "Many" lines of code, maybe even nested, with try-catch blocks
};

是不是IMHO不是那么可读性和简洁，我通常会尽量让这些身体保持尽可能短。在最好的情况下，{括号}可以省略--但有疑问，可以通过引入包含lambda主体的方法来省略。在这种情况下，人们通常可以把它归结为最后一种方法：

方法4，带有方法参考。它可能有点主观，但我认为这是最易读的。该方法的优点是它是一个“构建块”，具有清晰的功能，可以在JavaDocs中明确指定。此外，您甚至可以考虑省略包装方法（上面称为PageLoaded4)，而将该方法作为public方法提供。以前调用的用户

ExpectedCondition<Boolean> condition = 
    ExpectedConditions::pageLoaded4();

然后可以直接使用该方法

ExpectedCondition<Boolean> condition = 
    ExpectedConditions::execute;