Java 当有接口参数时，是否可以自动选择适当的类方法？

好的，我已经搜索过了，但是我找不到这个问题的答案。这可能是一个反复出现的问题，我不知道正确的术语来指代它，因此非常感谢您的帮助。：）

假设我们有一个方法m0，它从接口I，对象I接收一个对象

类A和B扩展接口I，所以对象I可以是类A或类B

然后，在方法m1中，我想在接口I，mi中使用一个声明的方法，它接收接口I的参数

在类A和类B中，我实现了mi，我希望mi按照参数进行操作。如果mi接收到类A的对象，我希望它使用来自类A的mi实现，否则，我希望来自类B的实现。但是，如果对象是A或B的实例，我不希望签入方法m0，因为我希望该方法是独立的，并且只依赖于接口I。有可能我会想引入更多扩展接口I的类

public boolean m0(I i1, I i2){
   return i1.mi(i2);
}

public interface I{
   public boolean mi(I i);
}

class A implements I{

   boolean boolValue;
   ...
   mi(I i){
     if(this.boolValue == i.boolValue)
        return true;
     return false;
   }
}

class B implements I{

   int intValue;
   ...
   mi(I i){
      if(this.intValue == i.intValue)
         return true;
      return false;
   }
}

我们的想法是A类和B类本质上是不同的，但我希望它们有共同的mi方法。因此i1.mi（i2）应该根据参数i2进行调整。可以保证i1和i2在m0中始终属于同一类。然而，在这两个类上的m0方法实现中，我不允许访问I对象属性booleanValue或intValue（取决于参数类型）

我编辑了这个问题，因为我没有正确地解释这个问题，无论如何，谢谢你迄今为止的答案

谢谢

---

编辑：这个问题解决了。为了实现我想要的行为，可以使用泛型类型

你似乎把事情弄得很复杂。您的实现应该返回您想要的值，仅此而已，并且不需要指向自身的指针，因为您可以使用它

public boolean m0(I i){
   return i.mi();
}

public interface I{
   public boolean mi();
}

class A implements I{

   boolean a = true;

   mi(){
      return this.a;
   }
}

class B implements I{

   boolean b = false;

   mi(){
      return this.b;
   }
}

当然，在您的精确示例中，您可以硬编码方法中的值：

class A implements I{

   boolean mi(){
      return true;
   }
}

注意：您需要使用

实现

而不是

扩展

，因为I是一个接口

编辑： 你已经澄清了这个问题。我不太确定你是如何得出这样一个设计的，所以也许你应该回顾一下你的整个设计，但考虑到你的问题，这就是你如何实现它的。基本上，在接口上添加一个泛型类型，以便接口充当该类型的包装器。 代码可能比任何冗长的解释更容易理解：

public <T> boolean m0(I<T> i1, I<T> i2){
   return i1.mi(i2.getT());
}

public interface I<T>{
   public T getT(); 

   public boolean mi(T i);
}

class A implements I<A>{

   boolean boolValue;

   public A getT() {
        return this;
    }

   public boolean mi(A i){
     if(this.boolValue == i.boolValue)
        return true;
     return false;
   }
}

class B implements I<B>{

   int intValue;

   public B getT() {
        return this;
    }


   public boolean mi(B i){
      if(this.intValue == i.intValue)
         return true;
      return false;
   }
} 

公共布尔值m0（iI1，iI2）{
返回i1.mi（i2.getT（））；
}
公共接口I{
公共T getT（）；
公共布尔mi（ti）；
}
A级执行器I{
布尔布尔布尔值；
公共A getT（）{
归还这个；
}
公共布尔mi（ai）{
if（this.boolValue==i.boolValue）
返回true；
返回false；
}
}
B类工具I{
int值；
公共B getT（）{
归还这个；
}
公共布尔mi（bi）{
if（this.intValue==i.intValue）
返回true；
返回false；
}
} 

---

因此，您的类都定义了一个返回自身的

getT（）

，以及一个获取确切子类的方法mi。编译器还保证您只能使用匹配的类型调用m0。

您似乎使问题变得非常复杂。您的实现应该返回您想要的值，仅此而已，并且不需要指向自身的指针，因为您可以使用它

public boolean m0(I i){
   return i.mi();
}

public interface I{
   public boolean mi();
}

class A implements I{

   boolean a = true;

   mi(){
      return this.a;
   }
}

class B implements I{

   boolean b = false;

   mi(){
      return this.b;
   }
}

当然，在您的精确示例中，您可以硬编码方法中的值：

class A implements I{

   boolean mi(){
      return true;
   }
}

注意：您需要使用

实现

而不是

扩展

，因为I是一个接口

编辑： 你已经澄清了这个问题。我不太确定你是如何得出这样一个设计的，所以也许你应该回顾一下你的整个设计，但考虑到你的问题，这就是你如何实现它的。基本上，在接口上添加一个泛型类型，以便接口充当该类型的包装器。 代码可能比任何冗长的解释更容易理解：

public <T> boolean m0(I<T> i1, I<T> i2){
   return i1.mi(i2.getT());
}

public interface I<T>{
   public T getT(); 

   public boolean mi(T i);
}

class A implements I<A>{

   boolean boolValue;

   public A getT() {
        return this;
    }

   public boolean mi(A i){
     if(this.boolValue == i.boolValue)
        return true;
     return false;
   }
}

class B implements I<B>{

   int intValue;

   public B getT() {
        return this;
    }


   public boolean mi(B i){
      if(this.intValue == i.intValue)
         return true;
      return false;
   }
} 

公共布尔值m0（iI1，iI2）{
返回i1.mi（i2.getT（））；
}
公共接口I{
公共T getT（）；
公共布尔mi（ti）；
}
A级执行器I{
布尔布尔布尔值；
公共A getT（）{
归还这个；
}
公共布尔mi（ai）{
if（this.boolValue==i.boolValue）
返回true；
返回false；
}
}
B类工具I{
int值；
公共B getT（）{
归还这个；
}
公共布尔mi（bi）{
if（this.intValue==i.intValue）
返回true；
返回false；
}
} 

---

因此，您的类都定义了一个返回自身的

getT（）

，以及一个获取确切子类的方法mi。编译器还保证您只能使用匹配的类型调用m0。

您似乎使问题变得非常复杂。您的实现应该返回您想要的值，仅此而已，并且不需要指向自身的指针，因为您可以使用它

public boolean m0(I i){
   return i.mi();
}

public interface I{
   public boolean mi();
}

class A implements I{

   boolean a = true;

   mi(){
      return this.a;
   }
}

class B implements I{

   boolean b = false;

   mi(){
      return this.b;
   }
}

当然，在您的精确示例中，您可以硬编码方法中的值：

class A implements I{

   boolean mi(){
      return true;
   }
}

注意：您需要使用

实现

而不是

扩展

，因为I是一个接口

编辑： 你已经澄清了这个问题。我不太确定你是如何得出这样一个设计的，所以也许你应该回顾一下你的整个设计，但考虑到你的问题，这就是你如何实现它的。基本上，在接口上添加一个泛型类型，以便接口充当该类型的包装器。 代码可能比任何冗长的解释更容易理解：

public <T> boolean m0(I<T> i1, I<T> i2){
   return i1.mi(i2.getT());
}

public interface I<T>{
   public T getT(); 

   public boolean mi(T i);
}

class A implements I<A>{

   boolean boolValue;

   public A getT() {
        return this;
    }

   public boolean mi(A i){
     if(this.boolValue == i.boolValue)
        return true;
     return false;
   }
}

class B implements I<B>{

   int intValue;

   public B getT() {
        return this;
    }


   public boolean mi(B i){
      if(this.intValue == i.intValue)
         return true;
      return false;
   }
} 

公共布尔值m0（iI1，iI2）{
返回i1.mi（i2.getT（））；
}
公共接口I{
公共T getT（）；
公共布尔mi（ti）；
}
A级执行器I{
布尔布尔布尔值；
公共A getT（）{
归还这个；
}
公共布尔mi（ai）{
if（this.boolValue==i.boolValue）
返回true；
返回false；
}
}
B类工具I{
int值；
公共B getT（）{
归还这个；
}
公共布尔mi（bi）{
如果（这个）