O parâmetro de uma função Java pode exigir interfaces opcionais?

Eu tenho duas interfaces em Java (versão 8) que são muito semelhantes. Não posso alterar as interfaces e não posso alterar as classes que as implementam.

public interface A {
    int get();
}

public interface B {
    int get();
    int somethingelse();
}

Agora eu tenho uma função que sua implementação se encaixa nas duas interfaces (quase). Eu quero fazer algo assim:

public int foo((A | B) p) {
    int ret = 0;
    if (p instanceof B) {
        ret = p.somthingelse();
    }
    return ret + p.get();
}

Não quero usar a inspeção porque esta função está no pipeline principal do meu programa. Eu quero que ele tenha um bom desempenho. É possível fazer isso em Java?

Editar:

Uma solução simples será copiar / colar foo()e implementá-lo de maneira diferente para cada interface. Mas, na realidade, foo()as interfaces são muito mais longas que isso e estou tentando evitar a duplicação de código.

Infelizmente, não há como criar esse tipo de relacionamento retroativo entre dois tipos não relacionados.

Se você puder alterar foo()e suas invocações, poderá usar interfaces funcionais que correspondem às assinaturas que você invoca dentro foo. Estou usando IntSupplieraqui, com expressões lambda correspondentes usando implementações concretas de Ae B.

Digamos que você tenha estas implementações:

class AImpl implements A {
     //implementation
}
class BImpl implements B {
     //implementation
}

Você pode mudar foopara algo como:

public int foo(IntSupplier get, IntSupplier somethingElse) {
    int ret = 0;
    if (somethingElse != null) {
        ret = somethingElse.getAsInt();
    }
    return ret + get.getAsInt();
}

E chame assim:

A a = new AImpl();
B b = new BImpl();

int result = this.foo(a::get, b::somethingelse);

A única maneira que eu posso imaginar é isso:

public int foo(A p) {
    return internal_foo(p);
}

public int foo(B p) {
    return internal_foo(p);
}

private int internal_foo(Object p) {
    if (p instanceof A) {
        return ((A)p).get();
    }
    if (p instanceof B) {
        B b = (B)p;
        ret = b.somthingelse();
        return ret + b.get();
    }
    throw new ClassCastException("Wrong type");
}

Além disso, o Java não suporta isso diretamente, mas você pode criar manualmente um "wrapper de união de tipo". Algo assim:

abstract class AorB {
    public static AorB wrap(A a) {
        return new AWrapper(a);
    }

    public static AorB wrap(B b) {
        return new BWrapper(b);
    }

    abstract int get();
    abstract int somethingElse();
}

class AWrapper extends AorB {
    private final A a;

    AWrapper(A a) {
        this.a = a;
    }

    @Override
    int get() {
        return a.get();
    }

    @Override
    int somethingElse() {
        return 0;
    }
}

class BWrapper extends AorB {
    private final B b;

    BWrapper(B b) {
        this.b = b;
    }

    @Override
    int get() {
        return b.get();
    }

    @Override
    int somethingElse() {
        return b.somethingElse();
    }
}

// and then

public int foo(A a) {
    return fooImpl(AorB.wrap(a));
}

public int foo(B b) {
    return fooImpl(AorB.wrap(b));
}

int fooImpl(AorB p) {
    return p.get() + p.somethingElse();
}

Você também pode adicionar algumas funções de inspeção como hasSomethingElse(), se não houver um valor padrão apropriado para retornar, como 0acima.