如何为接口实现创建多态方法？重载未触发问题解惑

我有一个接口I，定义了一个与其他I实例交互的方法：

public interface I {
    I interactWith(I other);
}

我有多个实现该接口的类，比如A、B、C、D。部分类的交互逻辑很简单，但有些类的交互依赖对方的类型——比如B和A交互的逻辑，和它与C、D交互的逻辑完全不同。如果在B里用instanceof做类型判断，代码会变得非常混乱，请问正确的实现方案是什么？

我尝试在接口和B类中都添加了interactWith(A other)方法，但这个方法从来没被调用过。为什么重载不会选择更具体的方法？

补充示例代码：

public interface I {
    I interactWith(A other);
    I interactWith(I other);
}

public class B implements I {
    public I interactWith(A other) {
        System.out.println("我希望这个方法被调用");
    }

    public I interactWith(I other) {
        System.out.println("即使other是A类型，这个方法还是会被调用");
    }
}

public static void main(String []args) {
    List<I> list = Arrays.asList(new A(), new B());
    list.get(1).interactWith(list.get(0));
}

一、为什么重载方法没被调用？ #

Java的方法重载是编译时静态绑定，而非运行时动态绑定。在你的示例中，list.get(0)的编译时类型是I——尽管它的运行时类型是A，但编译器只会根据变量的编译时类型选择重载方法。因此编译器会匹配interactWith(I other)，运行时自然不会调用更具体的interactWith(A other)。

二、正确的实现方案：访问者模式（双重分发） #

你遇到的是典型的双重分发问题：需要根据两个对象的实际类型决定执行逻辑。访问者模式是解决这类问题的标准方案，能彻底避免instanceof的嵌套判断，让代码更清晰、易扩展。

实现步骤 #

1. 在接口I中添加接受访问者的方法

public interface I {
    I interactWith(I other);
    // 新增接受访问者的方法，用于触发双重分发
    I accept(IVisitor visitor);
}

2. 定义访问者接口IVisitor
   为每个实现类定义对应的访问方法，让访问者能根据目标类型执行不同逻辑：

public interface IVisitor {
    I visitA(A a);
    I visitB(B b);
    I visitC(C c);
    I visitD(D d);
}

3. 实现每个类的accept方法
   每个类的accept方法调用访问者对应的方法，将自身作为参数传入，完成第一次动态分发：

public class A implements I {
    @Override
    public I interactWith(I other) {
        // 委托给访问者处理交互逻辑
        return other.accept(new AVisitor());
    }

    @Override
    public I accept(IVisitor visitor) {
        return visitor.visitA(this);
    }
}

public class B implements I {
    @Override
    public I interactWith(I other) {
        return other.accept(new BVisitor());
    }

    @Override
    public I accept(IVisitor visitor) {
        return visitor.visitB(this);
    }
}
// C、D类的实现逻辑与A/B一致

4. 实现具体的访问者类
   以BVisitor为例，在其中定义B与不同类型交互的具体逻辑：

public class BVisitor implements IVisitor {
    @Override
    public I visitA(A a) {
        // B与A交互的特殊逻辑
        System.out.println("B与A交互的特殊逻辑");
        return new SomeResult(); // 返回交互后的结果实例
    }

    @Override
    public I visitB(B b) {
        // B与B交互的逻辑
        System.out.println("B与B交互的逻辑");
        return new SomeResult();
    }

    @Override
    public I visitC(C c) {
        // B与C交互的逻辑
        System.out.println("B与C交互的逻辑");
        return new SomeResult();
    }

    @Override
    public I visitD(D d) {
        // B与D交互的逻辑
        System.out.println("B与D交互的逻辑");
        return new SomeResult();
    }
}

方案原理 #

• 第一次分发：调用other.accept(visitor)时，根据other的运行时类型动态绑定到对应的accept方法。
• 第二次分发：在accept方法中，调用visitor.visitX(this)，此时this的实际类型明确，会匹配访问者中对应的visitX方法。
  通过两次分发，实现了根据两个对象的实际类型执行对应逻辑，完全规避了instanceof判断。

轻量化替代方案（仅适用于类层级稳定的场景） #

如果你的类层级不会频繁扩展，也可以用重载+强制类型转换优化，但这种方式违反开闭原则，扩展性差：

public class B implements I {
    public I interactWith(A other) {
        System.out.println("B与A交互的特殊逻辑");
        return ...;
    }

    public I interactWith(C other) {
        System.out.println("B与C交互的逻辑");
        return ...;
    }

    public I interactWith(D other) {
        System.out.println("B与D交互的逻辑");
        return ...;
    }

    @Override
    public I interactWith(I other) {
        if (other instanceof A) {
            return interactWith((A) other);
        } else if (other instanceof C) {
            return interactWith((C) other);
        } else if (other instanceof D) {
            return interactWith((D) other);
        }
        // 默认交互逻辑
        return ...;
    }
}

内容的提问来源于stack exchange，提问作者Becks