如何设计支持多实现的KeyPair接口并隐藏泛型方法？

针对你需要隐藏KeyPair接口中firstKey()、secondKey()这两个泛化废弃方法，同时为不同实现类提供语义化方法的需求，除了你提到的两种方案，还有以下可行的解决方案：

方案1：适配器模式（解耦核心类与旧接口） #

通过创建适配器类来适配语义化业务类和KeyPair接口，让核心业务类完全摆脱旧接口的约束，仅由适配器处理废弃方法的实现。

实现代码： #

// 核心语义化类，无需实现KeyPair接口
class PrivatePublicKeyPair {
    private final Key privateKey;
    private final Key publicKey;

    public PrivatePublicKeyPair(Key privateKey, Key publicKey) {
        this.privateKey = privateKey;
        this.publicKey = publicKey;
    }

    public Key getPrivateKey() {
        return privateKey;
    }

    public Key getPublicKey() {
        return publicKey;
    }
}

class PasswordEncryptionKeyPair {
    private final Key password;
    private final Key encryptionKey;

    public PasswordEncryptionKeyPair(Key password, Key encryptionKey) {
        this.password = password;
        this.encryptionKey = encryptionKey;
    }

    public Key getPassword() {
        return password;
    }

    public Key getEncryptionKey() {
        return encryptionKey;
    }
}

// 适配器类，负责适配旧接口
class PrivatePublicKeyPairAdapter implements KeyPair {
    private final PrivatePublicKeyPair pair;

    public PrivatePublicKeyPairAdapter(PrivatePublicKeyPair pair) {
        this.pair = pair;
    }

    @Override
    @Deprecated
    public Key firstKey() {
        return pair.getPrivateKey();
    }

    @Override
    @Deprecated
    public Key secondKey() {
        return pair.getPublicKey();
    }
}

class PasswordEncryptionKeyPairAdapter implements KeyPair {
    private final PasswordEncryptionKeyPair pair;

    public PasswordEncryptionKeyPairAdapter(PasswordEncryptionKeyPair pair) {
        this.pair = pair;
    }

    @Override
    @Deprecated
    public Key firstKey() {
        return pair.getPassword();
    }

    @Override
    @Deprecated
    public Key secondKey() {
        return pair.getEncryptionKey();
    }
}

优点： #

• 核心业务类与旧接口完全解耦，专注于语义化设计，不受废弃方法干扰
• 旧接口的适配逻辑集中在适配器中，后续移除KeyPair接口时只需删除适配器类，不影响业务代码

方案2：静态工厂方法+匿名内部类（简化适配逻辑） #

利用Java 8+的接口静态方法，在KeyPair接口中提供工厂方法，直接创建包含语义化方法的匿名内部类实例，同时实现废弃方法的逻辑。

实现代码： #

public interface KeyPair {

    @Deprecated
    default Key firstKey() {
        return getFirstKey();
    }

    @Deprecated
    default Key secondKey() {
        return getSecondKey();
    }

    Key getFirstKey();
    Key getSecondKey();

    // 生成公私钥对的工厂方法
    static KeyPair createPrivatePublicPair(Key privateKey, Key publicKey) {
        return new KeyPair() {
            @Override
            public Key getFirstKey() {
                return privateKey;
            }

            @Override
            public Key getSecondKey() {
                return publicKey;
            }

            // 对外暴露语义化方法
            public Key getPrivateKey() {
                return privateKey;
            }

            public Key getPublicKey() {
                return publicKey;
            }
        };
    }

    // 生成密码加密密钥对的工厂方法
    static KeyPair createPasswordEncryptionPair(Key password, Key encryptionKey) {
        return new KeyPair() {
            @Override
            public Key getFirstKey() {
                return password;
            }

            @Override
            public Key getSecondKey() {
                return encryptionKey;
            }

            public Key getPassword() {
                return password;
            }

            public Key getEncryptionKey() {
                return encryptionKey;
            }
        };
    }
}

注意事项： #

• 语义化方法属于匿名内部类的自定义方法，外部调用时需要进行类型转换（如((PrivatePublicKeyPair) keyPair).getPrivateKey()），适合内部业务场景使用，不对外暴露时体验更好

补充：已知方案的优化建议 #

抽象类方案优化 #

将firstKey()和secondKey()的实现逻辑封装在抽象类中，子类只需实现语义化方法并调用抽象类的废弃方法，避免重复代码：

public abstract class AbstractKeyPair implements KeyPair {
    private final Key firstKey;
    private final Key secondKey;

    protected AbstractKeyPair(Key firstKey, Key secondKey) {
        this.firstKey = firstKey;
        this.secondKey = secondKey;
    }

    @Override
    @Deprecated
    public Key firstKey() {
        return firstKey;
    }

    @Override
    @Deprecated
    public Key secondKey() {
        return secondKey;
    }
}

class PrivatePublicKeyPair extends AbstractKeyPair {
    public PrivatePublicKeyPair(Key privateKey, Key publicKey) {
        super(privateKey, publicKey);
    }

    public Key getPrivateKey() {
        return super.firstKey();
    }

    public Key getPublicKey() {
        return super.secondKey();
    }
}

class PasswordEncryptionKeyPair extends AbstractKeyPair {
    public PasswordEncryptionKeyPair(Key password, Key encryptionKey) {
        super(password, encryptionKey);
    }

    public Key getPassword() {
        return super.firstKey();
    }

    public Key getEncryptionKey() {
        return super.secondKey();
    }
}

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