2

我有一组这样定义的函数：

public void foo1(int a, int b){
    if (a > b){
        c++;
    }
}


public void foo2(int a, int b){
    if (a > b && b = 7){
        c++;
    }
}


public void foo3(int a, int b){
    if (a >= b){
        c++;
    }
}

仅在 a 和 b 的条件上有所不同。有没有办法将这些作为一个函数包含在内，我可以将条件设​​置为变量？或者类似的东西？

编辑：请注意这是一个简单的例子，我想知道是否可以将条件传递给函数

4

6 回答 6

7

对于通用解决方案，您可以定义一个接口：

public interface Predicate {
    public boolean eval(int a, int b);
}

然后定义你的功能：

public void foo(Predicate predicate, int a, int b) {
    if (predicate.eval(a, b)) {
        c++;
    }
}

然后你可以定义各种Predicate对象：

Predicate test1 = new Predicate() {
    @Override
    public boolean eval(int a, int b) {
        return a >= b;
    }
};
// etc.

并通过适合的任何一个foo()。

或者，您可以查看使用Callable接口Boolean作为类型参数。（但是，它不能接受参数，因此它不完全符合您的模式。）

于 2012-04-22T04:39:29.657 回答
2

您可以拥有一个这样的函数，它结合了所有条件：

public void foo(int a, int b) {
    if (a >= b && b == 7) {
        c++;
    }
}
于 2012-04-22T04:34:52.030 回答
1

想到的第一个解决方案实际上是

public void foo(int a, int b, boolean condition){
    if (condition){
        c++;
    }
}

该调用将“看起来像”传递一个条件：

foo( a, b, a>b );
foo( a, b, a > b && b = 7 );
foo( a, b, a>=b );

您实际上通过了条件测试的结果，但在许多情况下这已经足够了。

只是在这里添加它，因为它很简单，似乎没有其他人提到它。

于 2012-04-22T05:41:42.137 回答
0

@Nikhar 是对的，在处理此问题时您可以做的一件事是使用 OR 运算符来解决您的困惑

function foo( int a, int b ) {
 if ( ( a > b ) || (a > b && b = 7) || (a >= b) ) // if any of the condition is true then
    c++;  // increment it
}
于 2012-04-22T04:42:11.463 回答
0

你可以有一个像

public interface MyCondn{
  boolean check(int a, int b);
}

然后，

public void foo(MyCondn cond, int a, int b){

   if(cond.check(a,b))
      c++;
}

您可以将条件定义为

public class Foo1 implements MyCondn{
   boolean check(int a, int b){
      return a > b;
   }
}

进而，

classInsatnce.foo(new Foo1(), a,  b);
于 2012-04-22T04:44:36.393 回答
0

一旦 Java 获得 lambda，将函数作为参数（在这种情况下为谓词）传递将很容易实现，直到现在它们可以使用非常冗长的匿名内部函数来实现。例如，您所要求的可以以一种类型安全的通用方式实现，如下所示：

public class Test {

    private int c = 0;

    public void foo(Predicate<Integer, Integer> pred) {
        if (pred.condition()) {
            c++;
        }
    }

    public static void main(String[] args) {

        Test t = new Test();
        int a = 10;
        int b = 7;

        t.foo(new Predicate<Integer, Integer>(a, b) {
            @Override
            public boolean condition() {
                return a > b;
            }
        });

        t.foo(new Predicate<Integer, Integer>(a, b) {
            @Override
            public boolean condition() {
                return a > b && b == 7;
            }
        });

        t.foo(new Predicate<Integer, Integer>(a, b) {
            @Override
            public boolean condition() {
                return a >= b;
            }
        });

    }

}

abstract class Predicate<S, T> {
    S a;
    T b;
    Predicate(S a, T b) {
        this.a = a;
        this.b = b;
    }
    public abstract boolean condition();
}
于 2012-04-22T04:56:02.487 回答