Java 传递给类的接口如何从该类调用方法？

假设我有以下接口

public interface I {
    public int evaluate();
}

下一节课呢

public class A {
    // ...
    public int getX(){}
    public int evaluateX(I model){
        return model.evaluate();
    }
}

那么，我是否可以实现

I

class Model implements I {
    @Override
    public int evaluate() {
        return getX() + 1;
    }
}

其中实现正在调用类

a

的方法

我知道反射，但我想知道静态技术。

---

谢谢

简单的答案是不

而且，这看起来像是紧密耦合，因为接口必须知道它被注入的类

您可能需要使用

int

参数化

evaluate

方法及其实现，以便在类

A

中调用时将其作为

getX（）

传递，然后在

模型
类的
evaluate
实现中按
1
递增

编辑

正如所建议的，您可能希望进一步概括

您可以使用一个声明
int getX（）
方法的接口对其进行参数化，而不是使用
int
参数化
evaluate

反过来，
A
将调用
model.evaluate（this）
，而
model
的
evaluate
实现将更改为类似
return myGivenArgument.getX（）+1

由您根据上下文来决定这是否必要。
简单的答案是否定的

而且，这看起来像是紧密耦合，因为接口必须知道它被注入的类

您可能需要使用
int
参数化
evaluate
方法及其实现，以便在类
A
中调用时将其作为
getX（）
传递，然后在
模型
类的
evaluate
实现中按
1
递增

编辑

正如所建议的，您可能希望进一步概括

您可以使用一个声明
int getX（）
方法的接口对其进行参数化，而不是使用
int
参数化
evaluate

反过来，
A
将调用
model.evaluate（this）
，而
model
的
evaluate
实现将更改为类似
return myGivenArgument.getX（）+1

由您根据上下文决定是否有必要这样做。
为什么不使用LMBDA？看起来你的例子是一个很好的例子

public interface I {
    public int evaluate( Supplier<Integer> s);
}

public static class A {

    public int getX(){return 5;}

    public int evaluateX(I model){

        return model.evaluate( () -> getX() );
    }
}

public static class Model implements I {

    @Override
    public int evaluate(Supplier<Integer> s) {
        return s.get() + 1;
    }
}

公共接口I{
公共int评估（供应商）；
}
公共静态A类{
public int getX（）{return 5；}
公共int evaluateX（I型）{
返回模型。evaluate（（）->getX（））；
}
}
公共静态类模型实现了I{
@凌驾
公共int评估（供应商）{
返回s.get（）+1；
}
}
为什么不使用LMBDA？看起来你的例子是一个很好的例子

public interface I {
    public int evaluate( Supplier<Integer> s);
}

public static class A {

    public int getX(){return 5;}

    public int evaluateX(I model){

        return model.evaluate( () -> getX() );
    }
}

public static class Model implements I {

    @Override
    public int evaluate(Supplier<Integer> s) {
        return s.get() + 1;
    }
}

公共接口I{
公共int评估（供应商）；
}
公共静态A类{
public int getX（）{return 5；}
公共int evaluateX（I型）{
返回模型。evaluate（（）->getX（））；
}
}
公共静态类模型实现了I{
@凌驾
公共int评估（供应商）{
返回s.get（）+1；
}
}
您有Model和I之间的关系，但是I和getX之间的关系在哪里？我认为除了使用反射，没有其他方法可以做到这一点。您必须考虑这样一个事实，即并非所有从模型中调用函数的类都必须实现该函数。为什么不干脆让类A实现接口呢？有意义的名称可以帮助我们理解您的意图。如果希望接口方法I.evaluate（）调用
A.getX（）
，则将A对象传递给
I.evaluate（）
--
类I{public int evaluate（A myA）；}
。或者，您可以将A对象作为接口类型传递，以允许I.evaluate（）对多个定义进行操作--
类I{public int evaluate（IX myX）；}
@Dakoda这正是我的问题。那么如何指定关系？@Endzeit我很想找到一种不同的方法。你有Model和I之间的关系，但是I和getX之间的关系在哪里？我认为除了使用反射之外，没有其他方法可以做到这一点。您必须考虑这样一个事实，即并非所有从模型中调用函数的类都必须实现该函数。为什么不干脆让类A实现接口呢？有意义的名称可以帮助我们理解您的意图。如果希望接口方法I.evaluate（）调用
A.getX（）
，则将A对象传递给
I.evaluate（）
--
类I{public int evaluate（A myA）；}
。或者，您可以将A对象作为接口类型传递，以允许I.evaluate（）对多个定义进行操作--
类I{public int evaluate（IX myX）；}
@Dakoda这正是我的问题。那么如何指定关系呢？@Endzeit我真的很想找到一种不同的方法。真正的答案是肯定的，而且很简单，就是将类的实例作为参数传递给接口方法。@AndyThomas同意这是一种更好的通用解决方案，尽管它可能会变得有些过分。您需要一个接口声明
getX
，该接口由
A
实现，然后声明
evaluate（MyNewInterface foo）
@andythonas如果您将具体类作为参数传递，那么即使使用接口也应该考虑原因。如果耦合得那么紧密，那么接口就变得过时了，功能也可以在类中实现。为了避免这种情况，我建议使用两个接口，一个是c