Question

我是Java的新手并且有一个问题：是否有任何干净的方法将下面的代码包装在一个函数中，这将获得任何表达式（由箭头指向）作为参数？

Foo A, B;
...

try {
    wait.until(new Function<WebDriver, Boolean>() {
        public Boolean apply(WebDriver driver) {
            return A.equals(B); // <=================== some expression 
        }
}
catch (Exception ex) {
  return false;
}
return true;

Answer 1

您需要一个接口或一个抽象类来执行此操作。在这种情况下，接口（两者中的一个）是更好的选择。

如果一个类实现了一个接口，那么必须具有接口中列出的功能。因此，当您接受函数中的接口时，您知道该对象已列出该函数（您可以调用它）。

您将定义如下界面：

public interface Test {
    public boolean passedTest();
}

然后，您将定义实现Test的类：

public EqualsTest implements Test {
    private Foo A, B;
    public EqualsTest(Foo A, Foo B){
        this.A = A;
        this.B = B;
    }
    @Overrides
    public boolean passedTest(){
        return A.equals(B);
    }
}

然后你的功能将如下所示：

public waitUntil(Test test){
    try{
        wait.until(new Function<WebDriver, Boolean>() {
            public Boolean apply(WebDriver driver) {
                return test.passedTest()
            }
        }
    } catch( Exception ex){
        return false;
    }
    return true;
}

Answer 2

如果您不使用Java 8，则需要使用如下所示的Callback接口，然后调用泛型方法传入实现接口的匿名调用，并在调用方法体中提供验证逻辑。另见这个答案

How to pass a function as a parameter in Java?

  @Test
    public void test() {    
        final Object a = new Object();
        final Object b = new Object();

        boolean result = waitUntil(new Callable() {
            public boolean call() {
                return a.equals(b);
            }
        });

        assertTrue(result);
    }

    public boolean waitUntil(final Callable func) {
        try {
            wait.until(new Function<WebDriver, Boolean>() {
                public Boolean apply(WebDriver driver) {
                    return func.call();// <=================== some expression 
                }
            }); 
        } catch (Exception ex) {
            return false;
        }
        return true;
    }


    public interface Callable {
        public boolean call();
    }

Answer 3

是的 - 有点儿。如果你只限于Java 7或更低版本，它将不会那么干净，但是你可以使用类似抽象工厂方法的东西将逻辑提取到它自己的类中（我已经为Selenium做了好几次这样的事情）： / p>

public abstract class FunctionFactory<T> {

    public abstract boolean execute(T t1, T t2);

    public static final FunctionFactory<T> WAIT_UNTIL_EQUALS = new FunctionFactory<T>() {

        @Override
        public boolean execute(T t1, T t2) {

            try {
                wait.until(new Function<WebDriver, Boolean>() {
                    public Boolean apply(WebDriver driver) {
                        return t1.equals(t2);
                    }
                }
            } catch (Exception ex) {
                return false;
            }
            return true;
        }

    }
}

然后，像这样实现你的方法：

public boolean waitUntil(FunctionFactory factory, t1, t2) {
    return factory.execute(t1, t2);
}

然后你可以这样称呼它：

waitUntil(WAIT_UNTIL_EQUALS, t1, t2);

在Java中包装Selenium wait.until函数，作为参数

3 个答案: