Question

我有一组定义如下的函数：

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的条件不同。有没有办法将这些作为一个函数包含在内，我可以将条件设置为变量？或类似的东西？

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

Answer 1

对于一般解决方案，您可以定义界面：

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()的任何一个。

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

Answer 2

你可以有一个这样的功能，它结合了所有条件：

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

Answer 3

首先想到的解决方案实际上是

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

电话会看起来像＆＃34;通过条件：

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

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

只需在此处添加，因为它很简单，似乎没有其他人提及它。

Answer 4

@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
}

Answer 5

你可以拥有像

这样的界面

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);

Answer 6

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

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();
}

java具有不同条件的类似函数

6 个答案: