如何根据接口类型分离实现双接口类中getString()方法的逻辑？

首先明确：Java中instanceof无法完成这个需求——因为不管用A还是B类型的引用指向ImplementationAB实例，a instanceof B和b instanceof A都会返回true，它只能判断实例是否实现了某个接口，无法区分调用时使用的是哪个接口引用。

下面提供两种可行的解决方案：

方案一：实例化时指定角色标记 #

在ImplementationAB中添加一个标记字段，创建实例时明确它要扮演的接口角色，内部根据标记执行不同逻辑：

interface A {
    String getString();
}

interface B {
    String getString();
}

// 定义枚举标记实例的接口角色
enum InstanceRole {
    ROLE_A, ROLE_B
}

class ImplementationAB implements A, B {
    private final InstanceRole role;

    // 构造时指定角色
    public ImplementationAB(InstanceRole role) {
        this.role = role;
    }

    @Override
    public String getString() {
        switch (role) {
            case ROLE_A:
                return "执行接口A对应的逻辑";
            case ROLE_B:
                return "执行接口B对应的逻辑";
            default:
                throw new IllegalArgumentException("无效的实例角色");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        A a = new ImplementationAB(InstanceRole.ROLE_A);
        B b = new ImplementationAB(InstanceRole.ROLE_B);

        System.out.println(a.getString()); // 输出：执行接口A对应的逻辑
        System.out.println(b.getString()); // 输出：执行接口B对应的逻辑
    }
}

这种方式简单直接，代码可读性高，适合大多数业务场景。

方案二：使用动态代理拦截调用 #

通过动态代理在调用层区分接口类型，将请求转发到不同的逻辑实现：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface A {
    String getString();
}

interface B {
    String getString();
}

class ImplementationAB {
    // 拆分出对应两个接口的逻辑方法
    public String getStringForA() {
        return "接口A专属逻辑结果";
    }

    public String getStringForB() {
        return "接口B专属逻辑结果";
    }
}

public class Main {
    public static void main(String[] args) {
        ImplementationAB coreImpl = new ImplementationAB();

        // 创建A接口的代理实例
        A aProxy = (A) Proxy.newProxyInstance(
                A.class.getClassLoader(),
                new Class[]{A.class},
                (proxy, method, args) -> coreImpl.getStringForA()
        );

        // 创建B接口的代理实例
        B bProxy = (B) Proxy.newProxyInstance(
                B.class.getClassLoader(),
                new Class[]{B.class},
                (proxy, method, args) -> coreImpl.getStringForB()
        );

        System.out.println(aProxy.getString()); // 输出：接口A专属逻辑结果
        System.out.println(bProxy.getString()); // 输出：接口B专属逻辑结果
    }
}

动态代理适合需要解耦接口角色与核心逻辑的场景，不过代码复杂度稍高，适合框架级或需要灵活扩展的场景。

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